From 45425bcb68f8c9994b47038e05b62caf9237c4c7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 5 Nov 2026 00:50:11 +0000
Subject: [PATCH 1/4] wip(app-shell): personal view conditions as Filter panel
 rows, save to the view (#30073)

Claude-Session: https://claude.ai/code/session_01QSeKYpFBMr917PmVkG9up7
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../src/views/ListPersonalizedMarker.tsx      | 24 +++++-
 .../app-shell/src/views/ObjectView.tsx        | 75 ++++++++++++++++--
 .../src/views/objectViewListRenderer.tsx      | 21 ++++-
 .../src/views/objectViewListUrlState.ts       | 15 ++++
 .../app-shell/src/views/personalViews.ts      | 79 ++++++++++++++++++-
 ui/packages/plugin-list/src/ListView.tsx      | 26 +++++-
 6 files changed, 222 insertions(+), 18 deletions(-)

diff --git a/ui/packages/app-shell/src/views/ListPersonalizedMarker.tsx b/ui/packages/app-shell/src/views/ListPersonalizedMarker.tsx
index 6a241e3b002..04df40a5f0c 100644
--- a/ui/packages/app-shell/src/views/ListPersonalizedMarker.tsx
+++ b/ui/packages/app-shell/src/views/ListPersonalizedMarker.tsx
@@ -9,6 +9,10 @@
  * (`useObjectViewListUrlState`'s `handleResetView`). Nothing here is
  * configurable: no metadata key or option reaches it.
  *
+ * On one of the reader's own views (objectstack#30073) it also offers 保存
+ * (`onSave`): the list on screen becomes the view's stored body. Edits not
+ * saved stay the reader's temporary list state, never written to the view.
+ *
  * Below `sm` the trigger is an icon alone (named by its `aria-label`), so on a
  * narrow row it never pushes the view name out.
  */
@@ -17,7 +21,7 @@ import { useState } from 'react';
 import { Button, Popover, PopoverContent, PopoverTrigger, cn } from '@object-ui/components';
 import { useObjectTranslation } from '@object-ui/i18n';
 import type { ListViewProps } from '@object-ui/plugin-list';
-import { RotateCcw, UserPen } from 'lucide-react';
+import { RotateCcw, Save, UserPen } from 'lucide-react';
 
 /** One part of a list that can differ from its view (`ListView`'s vocabulary). */
 export type ListPersonalizationPart = Parameters<NonNullable<ListViewProps['onPersonalizationChange']>>[0][number];
@@ -40,10 +44,13 @@ const LIST_PERSONALIZATION_PART_ORDER: readonly ListPersonalizationPart[] = [
 export function ListPersonalizedMarker({
   parts,
   onReset,
+  onSave,
   className,
 }: {
   parts: ReadonlyArray<ListPersonalizationPart>;
   onReset: () => void;
+  /** Save the list on screen into the open view; offered only for a view the reader owns and may update. */
+  onSave?: () => void;
   className?: string;
 }) {
   const { t } = useObjectTranslation();
@@ -97,6 +104,21 @@ export function ListPersonalizedMarker({
             </li>
           ))}
         </ul>
+        {onSave ? (
+          <Button
+            type="button"
+            size="sm"
+            className="mt-3 w-full gap-1.5"
+            data-testid="list-personalized-save"
+            onClick={() => {
+              setOpen(false);
+              onSave();
+            }}
+          >
+            <Save className="h-4 w-4" aria-hidden="true" />
+            {t('common.save')}
+          </Button>
+        ) : null}
         <p className="mt-3 text-xs text-muted-foreground">{t('console.objectView.resetViewTitle')}</p>
         <Button
           type="button"
diff --git a/ui/packages/app-shell/src/views/ObjectView.tsx b/ui/packages/app-shell/src/views/ObjectView.tsx
index b0e385f31d8..b8f8feeb00a 100644
--- a/ui/packages/app-shell/src/views/ObjectView.tsx
+++ b/ui/packages/app-shell/src/views/ObjectView.tsx
@@ -76,7 +76,13 @@ import { ObjectViewRecordOverlay } from './objectViewRecordOverlay.js';
 import { useObjectViewListRenderer } from './objectViewListRenderer.js';
 import { ListPersonalizedMarker } from './ListPersonalizedMarker.js';
 import { useObjectViewViewCrud } from './objectViewViewCrud.js';
-import { PERSONAL_VIEW_OBJECT, buildPersonalViewConfig, personalViewEntry, usePersonalViews } from './personalViews.js';
+import {
+    PERSONAL_VIEW_OBJECT,
+    buildPersonalViewConfig,
+    personalViewEntry,
+    personalViewPanelFilters,
+    usePersonalViews,
+} from './personalViews.js';
 import { PersonalViewNameDialog } from './PersonalViewNameDialog.js';
 import { parseListStateParams } from './userFilterUrlState.js';
 import { FILTER_FOLD_REFUSAL_KEYS } from './viewFilterFold.js';
@@ -657,6 +663,22 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
     const activeView = viewDraft && viewDraft.id === baseView?.id
         ? { ...baseView, ...viewDraft }
         : baseView;
+    // The list's toolbar state is read through this field gate wherever it is
+    // read (the seed, Save as my view, 保存): a field the object does not
+    // declare, or one this reader cannot read, is no list state.
+    const acceptListField = (field: string) =>
+        !!objectDef.fields?.[field]
+        && (!perms.isLoaded || perms.checkField(objectDef.name, field, 'read'));
+    // objectstack#30073 — a personal view's own conditions are Filter panel
+    // rows (`personalViewPanelFilters`), edited there and saved back by 保存.
+    // Keyed on the stored conditions' content (ui/AGENTS.md #10).
+    const activeIsPersonal = !!activeView?.id && personalViewIds.has(activeView.id);
+    const panelFiltersKey = activeIsPersonal ? JSON.stringify((activeView as any)?.filter ?? null) : '';
+    const viewPanelFilters = useMemo(
+        () => (panelFiltersKey ? personalViewPanelFilters(activeView, acceptListField) : undefined),
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed on the content the fold reads
+        [panelFiltersKey, objectDef, perms.isLoaded],
+    );
 
     // objectstack#25992 slice 8: the header toolbar actions, the nav `runAction` deep link
     // and the `action:bar` node moved to `./objectViewHeaderToolbar.ts`.
@@ -675,6 +697,7 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
         handleListPersonalizationChange,
         listPersonalizedParts,
         handleResetView,
+        clearSourceListState,
     } = useObjectViewListUrlState({
         objectName,
         objectDef,
@@ -689,8 +712,42 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
     // objectstack#28950 — the 「Personalized」 marker beside the list title (the
     // page header's badge slot, and the phone title): drawn only while the
     // reader's list differs from the view, and the one way back to it.
+    // objectstack#30073 — 保存: the list on screen written back into the open
+    // personal view, through the body Save as my view builds (so the stored
+    // shape is the same), then the reader's list state for it is cleared and
+    // the list opens again on the saved view. A panel the fold cannot write
+    // losslessly keeps the refusal Save as my view gives.
+    const canUpdatePersonalView = activeIsPersonal
+        && personalViews.status === 'ready'
+        && (!perms.isLoaded || perms.can(PERSONAL_VIEW_OBJECT, 'update'));
+    const handleSaveToPersonalView = async () => {
+        if (!activeView || !activeIsPersonal) return;
+        const built = buildPersonalViewConfig(objectDef.name, activeView, {
+            url: parseListStateParams(searchParams, acceptListField),
+            preference: listPrefs.preference.perView?.[activeView.id],
+            panelFilters: viewPanelFilters,
+        });
+        if (!built.ok) {
+            toast.error(t('form.saveError'), { description: t(FILTER_FOLD_REFUSAL_KEYS[built.reason]) });
+            return;
+        }
+        try {
+            await personalViews.update(activeView.id, built.config);
+            handleResetView();
+        } catch (err) {
+            console.error('[ObjectView] Failed to save a personal view:', err);
+            toast.error(t('form.saveError'), {
+                description: err instanceof Error ? err.message : String(err),
+                classNames: { description: 'whitespace-pre-line' },
+            });
+        }
+    };
     const personalizedMarker = !isEnvironmentList && listPersonalizedParts.length > 0 ? (
-        <ListPersonalizedMarker parts={listPersonalizedParts} onReset={handleResetView} />
+        <ListPersonalizedMarker
+            parts={listPersonalizedParts}
+            onReset={handleResetView}
+            onSave={canUpdatePersonalView ? () => { void handleSaveToPersonalView(); } : undefined}
+        />
     ) : null;
 
     // objectstack#25992 slice 11b: the view-config save and create handlers, view switching
@@ -750,19 +807,22 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
         if (!activeView) return false;
         // The list's toolbar state is the address's (`uf_*`), through the same
         // field gate its seed reads it with.
-        const acceptField = (field: string) =>
-            !!objectDef.fields?.[field]
-            && (!perms.isLoaded || perms.checkField(objectDef.name, field, 'read'));
         const built = buildPersonalViewConfig(objectDef.name, activeView, {
-            url: parseListStateParams(searchParams, acceptField),
+            url: parseListStateParams(searchParams, acceptListField),
             preference: listPrefs.preference.perView?.[activeView.id],
+            panelFilters: viewPanelFilters,
         });
         if (!built.ok) {
             toast.error(t('form.saveError'), { description: t(FILTER_FOLD_REFUSAL_KEYS[built.reason]) });
             return false;
         }
         try {
-            openPersonalView(await personalViews.save(label, built.config));
+            const savedId = await personalViews.save(label, built.config);
+            // objectstack#30073 — the list now lives in the saved view; the
+            // view it came from returns to its own (no temporary conditions,
+            // not personalized).
+            clearSourceListState(activeView.id);
+            openPersonalView(savedId);
             return true;
         } catch (err) {
             console.error('[ObjectView] Failed to save a personal view:', err);
@@ -1006,6 +1066,7 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
         initialUfSelections,
         handleUserFilterSelectionsChange,
         handleListTotalChange,
+        viewPanelFilters,
     });
 
     // objectstack#25992 slice 9: the merged views and the plugin's `ObjectViewSchema`
diff --git a/ui/packages/app-shell/src/views/objectViewListRenderer.tsx b/ui/packages/app-shell/src/views/objectViewListRenderer.tsx
index 2c54fd62de4..61ce9ee879d 100644
--- a/ui/packages/app-shell/src/views/objectViewListRenderer.tsx
+++ b/ui/packages/app-shell/src/views/objectViewListRenderer.tsx
@@ -17,6 +17,7 @@ const ObjectChart = lazy(() =>
 );
 import { ListView, type ListViewProps } from '@object-ui/plugin-list';
 import type { ListViewSchema, TreeViewConfig } from '@object-ui/types';
+import type { FilterBuilderRowGroup } from '@object-ui/components';
 import type { useAuth } from '@object-ui/auth';
 import type { useActionTextLocalizer } from '@object-ui/react';
 import { useLocalization, type useObjectLabel, type useObjectTranslation } from '@object-ui/i18n';
@@ -77,6 +78,7 @@ export function useObjectViewListRenderer({
     initialUfSelections,
     handleUserFilterSelectionsChange,
     handleListTotalChange,
+    viewPanelFilters,
 }: {
     objectName: string | undefined;
     inSetup: ReturnType<typeof isSetupAppSegment>;
@@ -121,6 +123,13 @@ export function useObjectViewListRenderer({
     handleUserFilterSelectionsChange: ReturnType<typeof useObjectViewUrlFilters>['handleUserFilterSelectionsChange'];
     /** objectstack#27594 — the records the active view matched, for the title's count. */
     handleListTotalChange: (total: number) => void;
+    /**
+     * objectstack#30073 — the active view's own conditions when the Filter
+     * panel holds them as rows (a personal view, `personalViewPanelFilters`):
+     * the panel opens on them, they are not applied under the list a second
+     * time, and the list judges its 「Personalized」 filters against them.
+     */
+    viewPanelFilters?: FilterBuilderRowGroup;
 }) {
     // objectui#10694 — does the active view, as AUTHORED, declare a non-empty
     // `columns`? Booleans, so the relay keys on values and not on the memo's
@@ -529,7 +538,9 @@ export function useObjectViewListRenderer({
             // URL filters). Now: base ?? listSchema, concatenated with the URL
             // filters, and substituted as a whole.
             filter: (() => {
-                const base = (viewDef as any).filter ?? listSchema.filter;
+                // A view whose conditions the panel holds is filtered by the
+                // panel (objectstack#30073), never by its stored list as well.
+                const base = viewPanelFilters ? undefined : ((viewDef as any).filter ?? listSchema.filter);
                 const baseArr = Array.isArray(base) ? base : base ? [base] : [];
                 const combined = urlFilters.length ? [...baseArr, ...urlFilters] : base;
                 const resolved = substituteFilterTokens(combined, filterScope);
@@ -885,7 +896,7 @@ export function useObjectViewListRenderer({
                 // objectstack#28950 — and the view's own grouping, under a
                 // grouping the URL carries (the `grouping` rung above), so the
                 // list can tell the reader's from the view's.
-                viewDefaults={{ hiddenFields: viewHiddenFields, rowHeight: viewRowHeight, sort: viewSort, grouping: listSchema.grouping }}
+                viewDefaults={{ hiddenFields: viewHiddenFields, rowHeight: viewRowHeight, sort: viewSort, grouping: listSchema.grouping, filters: viewPanelFilters }}
                 // objectstack#28948 — those resets clear the user's state.
                 onRestoreViewDefaults={restoreViewDefaults}
                 // objectstack#28950 — what of the list differs from the view,
@@ -951,7 +962,9 @@ export function useObjectViewListRenderer({
                 onColumnStateChange={persistListColumnState}
                 userFilterSelections={initialUfSelections}
                 onUserFilterSelectionsChange={handleUserFilterSelectionsChange}
-                initialFilters={listSeed?.filters}
+                // objectstack#30073 — with no list state of the reader's own,
+                // a personal view's panel opens on the view's own conditions.
+                initialFilters={listSeed?.filters ?? viewPanelFilters}
                 initialSearchTerm={listSeed?.search}
                 // objectui#12606 — Setup's list opens without row numbers in
                 // the leading cell. A host prop, not a view key: a console
@@ -979,7 +992,7 @@ export function useObjectViewListRenderer({
                 dataSource={ds}
             />
         );
-    }, [inSetup, activeView, activeViewDeclaresColumns, activeViewIsSaved, objectDef, objectName, refreshKey, createRecord, urlFilters, initialUfSelections, handleUserFilterSelectionsChange, writeListUrlState, user?.id, pageOffersCreate, listAddRecordOpensCreate, listIdentityKey, listPrefs.ready, listPrefs.preference, listPrefs.patchView, handleListTotalChange, managedUsers, managedUserMarker, recordOpen, openAsPage, handleListRowsChange, phoneTitle, handleListPersonalizationChange, workspaceTimeZone]);
+    }, [inSetup, activeView, activeViewDeclaresColumns, activeViewIsSaved, objectDef, objectName, refreshKey, createRecord, urlFilters, initialUfSelections, handleUserFilterSelectionsChange, writeListUrlState, user?.id, pageOffersCreate, listAddRecordOpensCreate, listIdentityKey, listPrefs.ready, listPrefs.preference, listPrefs.patchView, handleListTotalChange, managedUsers, managedUserMarker, recordOpen, openAsPage, handleListRowsChange, phoneTitle, handleListPersonalizationChange, workspaceTimeZone, viewPanelFilters]);
 
     return { renderListView };
 }
diff --git a/ui/packages/app-shell/src/views/objectViewListUrlState.ts b/ui/packages/app-shell/src/views/objectViewListUrlState.ts
index 068d2fe758c..f26255eaaf3 100644
--- a/ui/packages/app-shell/src/views/objectViewListUrlState.ts
+++ b/ui/packages/app-shell/src/views/objectViewListUrlState.ts
@@ -303,7 +303,22 @@ export function useObjectViewListUrlState({
         resetPendingRef.current = true;
         setListResetGeneration(g => g + 1);
     }, [activeView?.id, listPrefs.resetView, user?.id, objectName]);
+    /**
+     * objectstack#30073 — the list the reader just saved as a view of its own
+     * leaves the view it came from: that view's stored list state (sort,
+     * filters, column layout, density, hidden fields, every part the saved
+     * body carries) and its cached search term go, and the address the page
+     * is leaving loses its `uf_*` params, so neither Back nor the next open
+     * of that view brings the conditions back, nor marks it personalized.
+     * The caller navigates to the saved view next.
+     */
+    const clearSourceListState = useCallback((viewId: string) => {
+        listPrefs.resetView(viewId);
+        clearListFilterState(buildListFilterKey(user?.id, objectName, viewId));
+        setSearchParams(prev => withoutListStateParams(prev), { replace: true });
+    }, [listPrefs.resetView, user?.id, objectName, setSearchParams]);
     return {
+        clearSourceListState,
         listIdentityKey,
         listSeedRef,
         ownListParamsRef,
diff --git a/ui/packages/app-shell/src/views/personalViews.ts b/ui/packages/app-shell/src/views/personalViews.ts
index fdcca2b17a3..220b8157ecc 100644
--- a/ui/packages/app-shell/src/views/personalViews.ts
+++ b/ui/packages/app-shell/src/views/personalViews.ts
@@ -31,6 +31,8 @@
 
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { createAuthenticatedFetch } from '@object-ui/auth';
+import type { FilterBuilderRowGroup } from '@object-ui/components';
+import { builderRulesOfSpecFilter } from '@object-ui/core';
 import type { usePermissions } from '@object-ui/permissions';
 import type { DataSource } from '@object-ui/types';
 import { foldFilterGroupToSpecRules, type FilterFoldRefusal } from './viewFilterFold.js';
@@ -117,12 +119,58 @@ export function personalViewEntry(view: PersonalView): Record<string, any> {
   };
 }
 
+/**
+ * A personal view's own conditions as Filter panel rows (objectstack#30073):
+ * the view is the reader's own, so its conditions are shown and edited where
+ * the reader filters, and a 保存 writes the panel back as the view's filter.
+ *
+ * `undefined` keeps the conditions where every other view keeps them, applied
+ * under the list and not drawn as rows:
+ * - the view declares no condition;
+ * - the stored list is one the panel cannot hold (`builderRulesOfSpecFilter`
+ *   reads `null`: an any-of group beside other conditions), or an element is
+ *   not a flat rule naming a field;
+ * - a condition names a field `acceptField` refuses (one the object no longer
+ *   declares, or the reader cannot read). The list state the panel writes is
+ *   read back through that same gate, which would drop the row, and the view
+ *   would then select more records than it declares.
+ *
+ * The rows carry the stored operator and value as authored; the fold that
+ * saves them (`foldFilterGroupToSpecRules`) writes them back unchanged.
+ */
+export function personalViewPanelFilters(
+  config: Record<string, unknown> | undefined,
+  acceptField: (field: string) => boolean,
+): FilterBuilderRowGroup | undefined {
+  const stored = config?.filter;
+  if (!Array.isArray(stored) || stored.length === 0) return undefined;
+  const shown = builderRulesOfSpecFilter(stored);
+  if (!shown || shown.rules.length === 0) return undefined;
+  const conditions: FilterBuilderRowGroup['conditions'] = [];
+  for (const [i, rule] of shown.rules.entries()) {
+    if (!isRecord(rule) || typeof rule.field !== 'string' || !rule.field || !acceptField(rule.field)) return undefined;
+    conditions.push({
+      id: `view-${i}`,
+      field: rule.field,
+      operator: typeof rule.operator === 'string' ? rule.operator : 'equals',
+      value: (rule.value ?? '') as FilterBuilderRowGroup['conditions'][number]['value'],
+    } as FilterBuilderRowGroup['conditions'][number]);
+  }
+  return { id: 'root', logic: shown.logic, conditions };
+}
+
 /** What the list on screen holds beyond its view's own body. */
 export interface PersonalViewListState {
   /** The toolbar state the address carries (`uf_*`); an absent part is the view's own. */
   url: Pick<ListUrlState, 'filters' | 'sort' | 'grouping'>;
   /** The reader's stored state for the view (`ui.list.<object>`), if any. */
   preference?: ListViewPreference;
+  /**
+   * The open view's own conditions when the Filter panel holds them as rows
+   * ({@link personalViewPanelFilters}): the panel is then the WHOLE filter,
+   * the view's conditions included, and is not laid over them a second time.
+   */
+  panelFilters?: FilterBuilderRowGroup;
 }
 
 /** The column a `columns` entry names: a bare name, or an entry's `field`. */
@@ -140,6 +188,8 @@ function columnName(column: unknown): string | undefined {
  *   spec rules by the one fold every explicit save uses
  *   (`foldFilterGroupToSpecRules`). A group it cannot fold losslessly (a
  *   nested group) refuses the save instead of storing another record set.
+ *   When the panel holds the view's own conditions (`state.panelFilters`),
+ *   the panel alone is the filter: the reader may have edited or removed one.
  * - **sort** and **grouping**: the ones the address carries; absent there,
  *   the view's own.
  * - **columns**: the view's, in the reader's dragged order, without the
@@ -156,9 +206,17 @@ export function buildPersonalViewConfig(
   view: Record<string, any>,
   state: PersonalViewListState,
 ): { ok: true; config: Record<string, unknown> } | { ok: false; reason: FilterFoldRefusal } {
-  const folded = foldFilterGroupToSpecRules(state.url.filters);
-  if (!folded.ok) return { ok: false, reason: folded.reason };
-  const filter = [...(Array.isArray(view.filter) ? view.filter : []), ...folded.rules];
+  const own: unknown[] = Array.isArray(view.filter) ? view.filter : [];
+  let filter: unknown[];
+  if (state.panelFilters && state.url.filters === undefined) {
+    // The panel holds the view's own conditions and the reader has not
+    // touched it: the stored list is kept as it is.
+    filter = own;
+  } else {
+    const folded = foldFilterGroupToSpecRules(state.url.filters);
+    if (!folded.ok) return { ok: false, reason: folded.reason };
+    filter = state.panelFilters ? folded.rules : [...own, ...folded.rules];
+  }
 
   const pref = state.preference;
   const hidden = new Set<string>(pref?.hiddenFields ?? (Array.isArray(view.hiddenFields) ? view.hiddenFields : []));
@@ -308,6 +366,19 @@ export function usePersonalViews({
     [dataSource, objectName, userId, settle],
   );
 
+  /**
+   * Save the list on screen back into one of the reader's views (保存,
+   * objectstack#30073): the row's `config` replaced by a body built the way
+   * Save as my view builds one, so the stored shape is the same.
+   */
+  const update = useCallback(
+    async (id: string, config: Record<string, unknown>): Promise<void> => {
+      await dataSource.update(PERSONAL_VIEW_OBJECT, id, { config });
+      settle((views) => views.map((v) => (v.id === id ? { ...v, config } : v)));
+    },
+    [dataSource, settle],
+  );
+
   /** Rename one of the reader's views. */
   const rename = useCallback(
     async (id: string, label: string): Promise<void> => {
@@ -330,5 +401,5 @@ export function usePersonalViews({
     [authFetch, settle],
   );
 
-  return { status, views, save, rename, remove };
+  return { status, views, save, update, rename, remove };
 }
diff --git a/ui/packages/plugin-list/src/ListView.tsx b/ui/packages/plugin-list/src/ListView.tsx
index 32146778cb5..26bdd1b5203 100644
--- a/ui/packages/plugin-list/src/ListView.tsx
+++ b/ui/packages/plugin-list/src/ListView.tsx
@@ -475,8 +475,17 @@ export interface ListViewProps {
    * carries over the view's in `schema`. Unlike the three above, a
    * `viewDefaults` without the `grouping` key leaves the grouping `schema`
    * opened with as the view's own.
+   *
+   * `filters` (objectstack#30073) are the view's own conditions, for a host
+   * that shows them as Filter panel rows (and passes them as
+   * `initialFilters`) instead of applying them under the list: the panel's
+   * finished conditions are then judged against these, so the view's own
+   * rows are not a personalization and an edit, a removal or a "Clear all"
+   * is. Absent ⇒ any finished panel condition is the reader's own, as before.
    */
-  viewDefaults?: Pick<ListViewSchema, 'hiddenFields' | 'rowHeight' | 'sort' | 'grouping'>;
+  viewDefaults?: Pick<ListViewSchema, 'hiddenFields' | 'rowHeight' | 'sort' | 'grouping'> & {
+    filters?: FilterBuilderRowGroup;
+  };
   /**
    * A reset to the view's own, told apart from a choice (objectstack#28948).
    * For a host that stores the user's preference and passes `viewDefaults`:
@@ -1011,6 +1020,16 @@ function isAppliedFilterRow(row: { operator: string; value?: unknown }): boolean
  * Returns `group` itself when every row is finished, so an emit with nothing
  * to drop hands the host the identity it had before.
  */
+/**
+ * A filter-panel group by what it selects: its rows' field, operator and
+ * value in order, and its logic once two rows make it matter. Never by row
+ * `id`, which the builder mints per row.
+ */
+function filterRowsKey(group: FilterBuilderRowGroup): string {
+  const rows = (group.conditions ?? []).map((c) => [c.field, c.operator, c.value ?? null]);
+  return JSON.stringify([rows.length > 1 ? group.logic ?? 'and' : 'and', rows]);
+}
+
 function appliedFilterGroup(group: FilterBuilderRowGroup): FilterBuilderRowGroup {
   const rows = group.conditions ?? [];
   const finished = rows.filter(isAppliedFilterRow);
@@ -5662,8 +5681,11 @@ export const ListView = React.forwardRef<ListViewHandle, ListViewProps>(({
     JSON.stringify((fields ?? []).map((f) => [f.field, f.order ?? 'asc']));
   const personalizationParts: ListPersonalizationPart[] = [];
   if (sortDiffersFromDeclared) personalizationParts.push('sort');
+  const viewPanelFilters = viewDefaults?.filters;
   if (
-    appliedFilterGroup(currentFilters).conditions.length > 0
+    (viewPanelFilters
+      ? filterRowsKey(appliedPanelFilters) !== filterRowsKey(appliedFilterGroup(viewPanelFilters))
+      : appliedPanelFilters.conditions.length > 0)
     || userFilterConditions.length > 0
     || appliedQueueSittingConditions.length > 0
   ) personalizationParts.push('filters');

From 499ed503bac6941c26e2f2f1407138c5f63dcc7f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 5 Nov 2026 00:57:27 +0000
Subject: [PATCH 2/4] test(app-shell): pin personal view conditions as panel
 rows, save back, source cleared (#30073)

Claude-Session: https://claude.ai/code/session_01QSeKYpFBMr917PmVkG9up7
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../ObjectView.personalViews-29635.test.tsx   | 135 +++++++++++++++++-
 .../app-shell/src/views/ObjectView.tsx        |   9 +-
 .../src/views/objectViewListUrlState.ts       |  28 ++++
 .../app-shell/src/views/personalViews.test.ts |  74 +++++++++-
 4 files changed, 242 insertions(+), 4 deletions(-)

diff --git a/ui/packages/app-shell/src/views/ObjectView.personalViews-29635.test.tsx b/ui/packages/app-shell/src/views/ObjectView.personalViews-29635.test.tsx
index e9bbe98deae..6b2a4cf0f25 100644
--- a/ui/packages/app-shell/src/views/ObjectView.personalViews-29635.test.tsx
+++ b/ui/packages/app-shell/src/views/ObjectView.personalViews-29635.test.tsx
@@ -82,6 +82,14 @@ vi.mock('@object-ui/collaboration', async (importOriginal) => ({
   useConflictResolution: () => ({ hasConflicts: false, resolveAllConflicts: () => {} }),
 }));
 
+// objectstack#30073 — a refused save is told through the toast.
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), {
+    success: vi.fn(), error: vi.fn(), info: vi.fn(),
+    warning: vi.fn(), loading: vi.fn(), dismiss: vi.fn(),
+  }),
+}));
+
 vi.mock('./MetadataInspector', () => ({
   MetadataPanel: () => null,
   useMetadataInspector: () => ({ showDebug: false, toggle: () => {} }),
@@ -91,8 +99,9 @@ vi.mock('./RecordDetailView', () => ({ RecordDetailView: () => null }));
 import { ObjectView } from './ObjectView';
 import { ExpressionProvider } from '../providers/ExpressionProvider';
 import { UserStateAdaptersProvider, useAttachListStateFamily } from '../context/UserStateAdapters';
-import { ListPreferencesProvider, listPreferenceKey } from '../context/ListPreferencesProvider';
+import { ListPreferencesProvider, listPreferenceKey, localListStateKey } from '../context/ListPreferencesProvider';
 import { applyListStateParams } from './userFilterUrlState';
+import { toast } from 'sonner';
 
 /** Every request the page sends through `fetch`: the owner's door among them. */
 const fetchCalls: Array<{ url: string; method: string }> = [];
@@ -219,6 +228,7 @@ beforeEach(() => {
   grants.denied.clear();
   localStorage.clear();
   fetchCalls.length = 0;
+  vi.mocked(toast.error).mockClear();
   Object.defineProperty(window, 'innerWidth', { value: 1440, configurable: true, writable: true });
 });
 
@@ -543,3 +553,126 @@ describe('objectstack#30034 — a personal view opened by its address never carr
     expect(JSON.stringify(listReads(page.dataSource).at(-1))).not.toContain('Rome');
   });
 });
+
+/**
+ * objectstack#30073 (ruling A) — a personal view's own conditions are Filter
+ * panel rows: opening the view seeds them, editing them offers 保存 to that
+ * view (the same stored shape Save as my view writes), and saving the list as
+ * a view of the reader's own leaves the view it came from as that view
+ * declares it. A panel the fold cannot write keeps today's refusal.
+ */
+describe('objectstack#30073 — a personal view\'s conditions are Filter panel rows, saved back by 保存', () => {
+  const ROME = { id: 'root', logic: 'and' as const, conditions: [{ id: 'r1', field: 'city', operator: 'equals', value: 'Rome' }] };
+  const romeLink = (path: string) => `${path}?${applyListStateParams(new URLSearchParams(), { filters: ROME as never }).toString()}`;
+  const storeListState = (state: unknown) => localStorage.setItem(localListStateKey('u1', 'crm_lead'), JSON.stringify(state));
+  const storedListState = () => JSON.parse(localStorage.getItem(localListStateKey('u1', 'crm_lead')) ?? '{}');
+  const filterTrigger = () => screen.getByTestId('toolbar-filter-trigger');
+  const lastLeadRead = (dataSource: ReturnType<typeof mountLeads>['dataSource']) => JSON.stringify(leadReads(dataSource).at(-1));
+
+  it('opening a personal view seeds its conditions as panel rows, applied once, and the list is not personalized', async () => {
+    const { dataSource } = mountLeads('/apps/crm/crm_lead/view/pv_mine');
+    await listToolbar();
+    expect(switcher()).toHaveTextContent('Paris leads');
+    await waitFor(() => expect(filterTrigger()).toHaveAttribute('aria-label', 'Filter, 1 active'));
+    fireEvent.click(filterTrigger());
+    expect(await screen.findByDisplayValue('Paris')).toBeInTheDocument();
+    // The panel row is the condition: it is not laid under the list as well.
+    await waitFor(() => expect(lastLeadRead(dataSource)).toContain('Paris'));
+    expect(lastLeadRead(dataSource).match(/Paris/g)).toHaveLength(1);
+    expect(screen.queryByTestId('list-personalized-marker')).toBeNull();
+    expect(dataSource.update).not.toHaveBeenCalled();
+  });
+
+  it('an edited panel is personalized and offers 保存, which writes the panel into that view in the stored shape', async () => {
+    const { dataSource } = mountLeads(romeLink('/apps/crm/crm_lead/view/pv_mine'));
+    await listToolbar();
+    const marker = await screen.findByTestId('list-personalized-marker');
+    // Nothing is written back while the edit is only on screen.
+    expect(dataSource.update).not.toHaveBeenCalled();
+    fireEvent.click(marker);
+    fireEvent.click(await screen.findByTestId('list-personalized-save'));
+
+    await waitFor(() => expect(dataSource.update).toHaveBeenCalledTimes(1));
+    const [resource, id, patch] = dataSource.update.mock.calls[0];
+    expect([resource, id, Object.keys(patch)]).toEqual(['sys_personal_view', 'pv_mine', ['config']]);
+    expect(ListViewSchema.safeParse(patch.config).success).toBe(true);
+    expect(patch.config.data).toEqual({ provider: 'object', object: 'crm_lead' });
+    expect(patch.config.filter).toEqual([{ field: 'city', operator: 'equals', value: 'Rome' }]);
+    // The list opens again on the saved view: its rows are the view's own.
+    await waitFor(() => expect(screen.queryByTestId('list-personalized-marker')).toBeNull());
+    await waitFor(() => expect(lastLeadRead(dataSource)).toContain('Rome'));
+    expect(lastLeadRead(dataSource)).not.toContain('Paris');
+  });
+
+  it('a reader without update on their views is not offered 保存', async () => {
+    grants.isLoaded = true;
+    grants.denied.add('sys_personal_view:update');
+    mountLeads(romeLink('/apps/crm/crm_lead/view/pv_mine'));
+    await listToolbar();
+    fireEvent.click(await screen.findByTestId('list-personalized-marker'));
+    await screen.findByTestId('list-personalized-reset');
+    expect(screen.queryByTestId('list-personalized-save')).toBeNull();
+  });
+
+  it('a panel the fold cannot write keeps the refusal: nothing is written to the view', async () => {
+    storeListState({
+      perView: {
+        pv_mine: {
+          filters: { id: 'root', logic: 'and', conditions: [{ id: 'g1', logic: 'or', conditions: [{ id: 'c1', field: 'city', operator: 'equals', value: 'Rome' }] }] },
+        },
+      },
+    });
+    const { dataSource } = mountLeads('/apps/crm/crm_lead/view/pv_mine');
+    await listToolbar();
+    fireEvent.click(await screen.findByTestId('list-personalized-marker'));
+    fireEvent.click(await screen.findByTestId('list-personalized-save'));
+    await waitFor(() => expect(toast.error).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ description: expect.stringContaining('nested condition groups') }),
+    ));
+    expect(dataSource.update).not.toHaveBeenCalled();
+  });
+
+  it('a stored list the panel cannot hold stays under the list, as for any other view', async () => {
+    const orBeside = {
+      ...OWN,
+      config: body({ filter: [{ field: 'status', operator: 'equals', value: 'open' }, { or: [{ field: 'city', operator: 'equals', value: 'Paris' }] }] }),
+    };
+    const { dataSource } = mountLeads('/apps/crm/crm_lead/view/pv_mine', { personalRows: [orBeside] });
+    await listToolbar();
+    await waitFor(() => expect(lastLeadRead(dataSource)).toContain('Paris'));
+    expect(lastLeadRead(dataSource)).toContain('open');
+    expect(filterTrigger()).toHaveAttribute('aria-label', 'Filter');
+  });
+
+  it('Save as my view leaves the view it came from without the temporary conditions and not personalized', async () => {
+    storeListState({ perView: { v1: { filters: ROME } } });
+    const first = mountLeads(romeLink('/apps/crm/crm_lead/view/v1'));
+    await listToolbar();
+    await screen.findByTestId('list-personalized-marker');
+
+    const menu = openSwitcher();
+    await waitFor(() => expect(within(menu).getByTestId('list-view-switcher-save-mine')).toBeInTheDocument());
+    fireEvent.click(within(menu).getByTestId('list-view-switcher-save-mine'));
+    const dialog = await screen.findByTestId('personal-view-name-dialog');
+    fireEvent.change(within(dialog).getByTestId('personal-view-name-input'), { target: { value: 'Rome leads' } });
+    fireEvent.click(within(dialog).getByTestId('personal-view-name-submit'));
+
+    await waitFor(() => expect(first.dataSource.create).toHaveBeenCalledTimes(1));
+    expect(first.dataSource.create.mock.calls[0][1].config.filter).toEqual([{ field: 'city', operator: 'equals', value: 'Rome' }]);
+    await waitFor(() => expect(switcher()).toHaveTextContent('Rome leads'));
+    // The new view holds the conditions as its own rows: nothing reads personalized.
+    await waitFor(() => expect(screen.queryByTestId('list-personalized-marker')).toBeNull());
+    // The source's stored list state is gone.
+    expect(storedListState().perView?.v1).toBeUndefined();
+    first.unmount();
+
+    const again = mountLeads('/apps/crm/crm_lead/view/v1');
+    await listToolbar();
+    expect(switcher()).toHaveTextContent('View 1');
+    await waitFor(() => expect(leadReads(again.dataSource).length).toBeGreaterThan(0));
+    expect(lastLeadRead(again.dataSource)).not.toContain('Rome');
+    expect(filterTrigger()).toHaveAttribute('aria-label', 'Filter');
+    expect(screen.queryByTestId('list-personalized-marker')).toBeNull();
+  });
+});
diff --git a/ui/packages/app-shell/src/views/ObjectView.tsx b/ui/packages/app-shell/src/views/ObjectView.tsx
index b8f8feeb00a..5dea2b11045 100644
--- a/ui/packages/app-shell/src/views/ObjectView.tsx
+++ b/ui/packages/app-shell/src/views/ObjectView.tsx
@@ -698,6 +698,7 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
         listPersonalizedParts,
         handleResetView,
         clearSourceListState,
+        readPanelFilters,
     } = useObjectViewListUrlState({
         objectName,
         objectDef,
@@ -723,7 +724,9 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
     const handleSaveToPersonalView = async () => {
         if (!activeView || !activeIsPersonal) return;
         const built = buildPersonalViewConfig(objectDef.name, activeView, {
-            url: parseListStateParams(searchParams, acceptListField),
+            // The panel's group is the one the list shows (an emptied panel
+            // included), not the address's copy of it.
+            url: { ...parseListStateParams(searchParams, acceptListField), filters: readPanelFilters() },
             preference: listPrefs.preference.perView?.[activeView.id],
             panelFilters: viewPanelFilters,
         });
@@ -808,7 +811,9 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
         // The list's toolbar state is the address's (`uf_*`), through the same
         // field gate its seed reads it with.
         const built = buildPersonalViewConfig(objectDef.name, activeView, {
-            url: parseListStateParams(searchParams, acceptListField),
+            // The panel's group is the one the list shows (an emptied panel
+            // included), not the address's copy of it.
+            url: { ...parseListStateParams(searchParams, acceptListField), filters: readPanelFilters() },
             preference: listPrefs.preference.perView?.[activeView.id],
             panelFilters: viewPanelFilters,
         });
diff --git a/ui/packages/app-shell/src/views/objectViewListUrlState.ts b/ui/packages/app-shell/src/views/objectViewListUrlState.ts
index f26255eaaf3..f4a7722870a 100644
--- a/ui/packages/app-shell/src/views/objectViewListUrlState.ts
+++ b/ui/packages/app-shell/src/views/objectViewListUrlState.ts
@@ -240,9 +240,22 @@ export function useObjectViewListUrlState({
         // resolution that ends on the fall-back keeps the identity unchanged.)
         // eslint-disable-next-line react-hooks/exhaustive-deps -- see above
     }, [listIdentityKey, listPrefs.ready, viewResolving]);
+    /**
+     * objectstack#30073 — the Filter panel's group as the list last reported
+     * it, held with the list identity it came from. The address cannot say
+     * this alone: a panel the reader emptied leaves no `uf_*` param, exactly as
+     * an untouched one does, and a group the URL form cannot carry is dropped
+     * from it. A save reads the panel here ({@link readPanelFilters}).
+     */
+    const listIdentityKeyRef = useRef(listIdentityKey);
+    listIdentityKeyRef.current = listIdentityKey;
+    const reportedPanelFiltersRef = useRef<{ key: string | undefined; filters: ListStatePatch['filters'] } | undefined>(undefined);
     /** Write the list's own change into the URL — replace, never a history entry per keystroke. */
     const writeListUrlState = useCallback(
         (patch: ListStatePatch) => {
+            if ('filters' in patch) {
+                reportedPanelFiltersRef.current = { key: listIdentityKeyRef.current, filters: patch.filters };
+            }
             setSearchParams(prev => {
                 const next = applyListStateParams(prev, patch);
                 ownListParamsRef.current = userFilterParamsKey(next);
@@ -312,6 +325,20 @@ export function useObjectViewListUrlState({
      * of that view brings the conditions back, nor marks it personalized.
      * The caller navigates to the saved view next.
      */
+    /**
+     * objectstack#30073 — the Filter panel's group on screen: the list's last
+     * report for this list, else the group the list opened with (its seed).
+     * `undefined` means the panel holds what the view hands it untouched; a
+     * panel the reader emptied is an empty group, never `undefined`.
+     */
+    const readPanelFilters = useCallback((): ListUrlState['filters'] => {
+        const reported = reportedPanelFiltersRef.current;
+        if (reported && reported.key === listIdentityKeyRef.current) {
+            return reported.filters ?? { id: 'root', logic: 'and', conditions: [] };
+        }
+        const seed = listSeedRef.current;
+        return seed && seed.key === listIdentityKeyRef.current ? seed.state.filters : undefined;
+    }, []);
     const clearSourceListState = useCallback((viewId: string) => {
         listPrefs.resetView(viewId);
         clearListFilterState(buildListFilterKey(user?.id, objectName, viewId));
@@ -319,6 +346,7 @@ export function useObjectViewListUrlState({
     }, [listPrefs.resetView, user?.id, objectName, setSearchParams]);
     return {
         clearSourceListState,
+        readPanelFilters,
         listIdentityKey,
         listSeedRef,
         ownListParamsRef,
diff --git a/ui/packages/app-shell/src/views/personalViews.test.ts b/ui/packages/app-shell/src/views/personalViews.test.ts
index 6a57c5f6f91..248c9d7c9f1 100644
--- a/ui/packages/app-shell/src/views/personalViews.test.ts
+++ b/ui/packages/app-shell/src/views/personalViews.test.ts
@@ -10,7 +10,7 @@
 
 import { describe, expect, it } from 'vitest';
 import { ListViewSchema } from '@objectstack/spec/ui';
-import { buildPersonalViewConfig, personalViewEntry, readPersonalViewRows } from './personalViews';
+import { buildPersonalViewConfig, personalViewEntry, personalViewPanelFilters, readPersonalViewRows } from './personalViews';
 
 const row = (extra: Record<string, unknown> = {}) => ({
   id: 'pv_1',
@@ -106,3 +106,75 @@ describe('buildPersonalViewConfig', () => {
     expect(buildPersonalViewConfig('crm_lead', VIEW, { url: { filters: nested as never } })).toEqual({ ok: false, reason: 'nested_group' });
   });
 });
+
+/**
+ * objectstack#30073 — a personal view's own conditions are Filter panel rows,
+ * and 保存 writes the panel back as the view's filter in the stored shape.
+ */
+describe('personalViewPanelFilters', () => {
+  const every = () => true;
+
+  it('reads a stored AND list as one panel row per condition, operator and value as stored', () => {
+    const group = personalViewPanelFilters({
+      filter: [
+        { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },
+        { field: 'close_date', operator: 'between', value: ['{quarter_start}', '{quarter_end}'] },
+      ],
+    }, every);
+    expect(group?.logic).toBe('and');
+    expect(group?.conditions.map(({ field, operator, value }) => ({ field, operator, value }))).toEqual([
+      { field: 'stage', operator: 'not_in', value: ['closed_won', 'closed_lost'] },
+      { field: 'close_date', operator: 'between', value: ['{quarter_start}', '{quarter_end}'] },
+    ]);
+  });
+
+  it('reads the one any-of group the fold writes for an OR panel as an OR group of rows', () => {
+    const group = personalViewPanelFilters({
+      filter: [{ or: [{ field: 'city', operator: 'equals', value: 'Paris' }, { field: 'city', operator: 'equals', value: 'Rome' }] }],
+    }, every);
+    expect(group?.logic).toBe('or');
+    expect(group?.conditions.map((c) => c.value)).toEqual(['Paris', 'Rome']);
+  });
+
+  it('leaves a list the panel cannot hold, a refused field, or no condition where every view keeps its conditions', () => {
+    const orBeside = [{ field: 'status', operator: 'equals', value: 'open' }, { or: [{ field: 'city', operator: 'equals', value: 'Paris' }] }];
+    expect(personalViewPanelFilters({ filter: orBeside }, every)).toBeUndefined();
+    expect(personalViewPanelFilters({ filter: [{ field: 'secret', operator: 'equals', value: 1 }] }, (f) => f !== 'secret')).toBeUndefined();
+    expect(personalViewPanelFilters({ filter: [] }, every)).toBeUndefined();
+    expect(personalViewPanelFilters({}, every)).toBeUndefined();
+  });
+});
+
+describe('buildPersonalViewConfig — a view whose conditions the panel holds', () => {
+  const OWN_FILTER = [{ field: 'city', operator: 'equals', value: 'Paris' }];
+  const VIEW = { id: 'pv_1', label: 'Paris leads', type: 'grid', columns: ['name', 'city'], filter: OWN_FILTER };
+  const panelFilters = personalViewPanelFilters(VIEW, () => true);
+
+  it('an untouched panel keeps the stored filter as it is', () => {
+    const built = buildPersonalViewConfig('crm_lead', VIEW, { url: { filters: undefined }, panelFilters });
+    expect(built.ok && built.config.filter).toEqual(OWN_FILTER);
+  });
+
+  it('an edited panel is the whole filter, in the stored shape, never laid over the view\'s own', () => {
+    const edited = { id: 'root', logic: 'and', conditions: [{ id: 'view-0', field: 'city', operator: 'equals', value: 'Rome' }] };
+    const built = buildPersonalViewConfig('crm_lead', VIEW, { url: { filters: edited as never }, panelFilters });
+    expect(built.ok).toBe(true);
+    if (!built.ok) return;
+    expect(built.config.filter).toEqual([{ field: 'city', operator: 'equals', value: 'Rome' }]);
+    expect(ListViewSchema.safeParse(built.config).success).toBe(true);
+  });
+
+  it('an emptied panel stores no filter', () => {
+    const built = buildPersonalViewConfig('crm_lead', VIEW, {
+      url: { filters: { id: 'root', logic: 'and', conditions: [] } as never },
+      panelFilters,
+    });
+    expect(built.ok && built.config.filter).toBeUndefined();
+  });
+
+  it('a group the fold cannot write losslessly keeps the refusal', () => {
+    const nested = { logic: 'and', conditions: [{ logic: 'or', conditions: [{ field: 'city', operator: 'equals', value: 'Paris' }] }] };
+    expect(buildPersonalViewConfig('crm_lead', VIEW, { url: { filters: nested as never }, panelFilters }))
+      .toEqual({ ok: false, reason: 'nested_group' });
+  });
+});

From 908050486b2c4c91b36a10500663455f76e7792d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 5 Nov 2026 01:00:02 +0000
Subject: [PATCH 3/4] test(plugin-list): pin viewDefaults.filters
 personalization; changeset (#30073)

Claude-Session: https://claude.ai/code/session_01QSeKYpFBMr917PmVkG9up7
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/30073-personal-view-conditions.md  | 15 +++++++++++
 .../ListView.personalization-28950.test.tsx   | 27 +++++++++++++++++++
 2 files changed, 42 insertions(+)
 create mode 100644 .changeset/30073-personal-view-conditions.md

diff --git a/.changeset/30073-personal-view-conditions.md b/.changeset/30073-personal-view-conditions.md
new file mode 100644
index 00000000000..fb180bb163e
--- /dev/null
+++ b/.changeset/30073-personal-view-conditions.md
@@ -0,0 +1,15 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/plugin-list': patch
+---
+
+feat(app-shell,plugin-list): a personal view's own conditions are Filter panel rows, and 保存 writes the panel back into that view
+
+Clause-②: no
+Metadata-protocol: none
+
+- **Opening one of the reader's own views (My views) shows its conditions as ordinary rows in the Filter panel**, with the active count on the Filter control. They are the list's filter while they are there: not applied under the list a second time, and not a personalization. A stored filter the panel cannot hold (an any-of group beside other conditions), or one naming a field the object no longer declares or the reader cannot read, stays applied under the list, as for any other view.
+- **Editing those rows marks the list 已个性化, and the marker offers 保存 to that view** (for a reader allowed to update their views). 保存 replaces the row's `config` through the data API with the body Save as my view builds, so the stored `ListView` shape is unchanged and no key is added; the reader's temporary list state for the view is then cleared and the list opens on the saved view. Edits not saved stay the reader's temporary list state and are never written to the view. A panel the fold cannot write losslessly keeps the refusal Save as my view gives, and nothing is written.
+- **Save as my view now clears the view it came from**: that view's stored list state (sort, filters, column layout, density, hidden fields) and cached search term go, and the address being left loses its `uf_*` params, so the source no longer reads filtered or 已个性化 after the save.
+- Both saves read the Filter panel as the list reports it, not the address's copy, so an emptied panel saves as no filter.
+- `@object-ui/plugin-list`: `ListView`'s host prop `viewDefaults` accepts `filters`, the view's own conditions for a host that shows them as panel rows; the `filters` personalization part is then judged against them.
diff --git a/ui/packages/plugin-list/src/__tests__/ListView.personalization-28950.test.tsx b/ui/packages/plugin-list/src/__tests__/ListView.personalization-28950.test.tsx
index 8d970b2fb2a..28ad31b625e 100644
--- a/ui/packages/plugin-list/src/__tests__/ListView.personalization-28950.test.tsx
+++ b/ui/packages/plugin-list/src/__tests__/ListView.personalization-28950.test.tsx
@@ -212,3 +212,30 @@ describe('with the callback wired, the host owns the one reset (objectstack#2895
     expect(screen.getByTestId('sort-reset-default')).toBeEnabled();
   });
 });
+
+/**
+ * objectstack#30073 — a host that shows the view's own conditions as Filter
+ * panel rows hands them in `viewDefaults.filters`: the panel holding exactly
+ * those rows is the view's own, and a changed or emptied panel is `filters`.
+ */
+describe('the view\'s own conditions as panel rows (`viewDefaults.filters`, objectstack#30073)', () => {
+  const OWN = { id: 'root', logic: 'and', conditions: [{ id: 'view-0', field: 'name', operator: 'contains', value: 'Acme' }] };
+  const withOwn = { viewDefaults: { ...VIEW_DEFAULTS, filters: OWN } as never };
+
+  it('the panel holding the view\'s own rows reports no part', async () => {
+    const { reported, onPersonalizationChange } = mount({}, { ...withOwn, initialFilters: OWN as never });
+    await waitFor(() => expect(onPersonalizationChange).toHaveBeenCalled());
+    await waitFor(() => expect(reported()).toEqual([]));
+  });
+
+  it('an edited panel is `filters`', async () => {
+    const edited = { ...OWN, conditions: [{ ...OWN.conditions[0], value: 'Globex' }] };
+    const { reported } = mount({}, { ...withOwn, initialFilters: edited as never });
+    await waitFor(() => expect(reported()).toEqual(['filters']));
+  });
+
+  it('an emptied panel is `filters` too', async () => {
+    const { reported } = mount({}, { ...withOwn, initialFilters: { id: 'root', logic: 'and', conditions: [] } as never });
+    await waitFor(() => expect(reported()).toEqual(['filters']));
+  });
+});

From 5fc9c61c8fa4aa2b3062d22dd20aadf6f88cc4e9 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 5 Nov 2026 03:17:26 +0000
Subject: [PATCH 4/4] fix(app-shell): read the save-to-view grant through
 personalGrant and enter its write site (#30073)

Claude-Session: https://claude.ai/code/session_01QSeKYpFBMr917PmVkG9up7
Co-authored-by: Claude <noreply@anthropic.com>
---
 ui/packages/app-shell/src/views/ObjectView.tsx         | 10 +++++-----
 .../plugin-form/src/affordanceGrantMap-12082.test.tsx  |  2 ++
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/ui/packages/app-shell/src/views/ObjectView.tsx b/ui/packages/app-shell/src/views/ObjectView.tsx
index 5dea2b11045..e61105bacb4 100644
--- a/ui/packages/app-shell/src/views/ObjectView.tsx
+++ b/ui/packages/app-shell/src/views/ObjectView.tsx
@@ -718,9 +718,11 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
     // shape is the same), then the reader's list state for it is cleared and
     // the list opens again on the saved view. A panel the fold cannot write
     // losslessly keeps the refusal Save as my view gives.
-    const canUpdatePersonalView = activeIsPersonal
-        && personalViews.status === 'ready'
-        && (!perms.isLoaded || perms.can(PERSONAL_VIEW_OBJECT, 'update'));
+    // The reader's own `sys_personal_view` rows: one grant read for Save as my
+    // view (create) and for Rename and 保存 (update).
+    const personalViewsReady = personalViews.status === 'ready';
+    const personalGrant = (action: 'create' | 'update') => !perms.isLoaded || perms.can(PERSONAL_VIEW_OBJECT, action);
+    const canUpdatePersonalView = activeIsPersonal && personalViewsReady && personalGrant('update');
     const handleSaveToPersonalView = async () => {
         if (!activeView || !activeIsPersonal) return;
         const built = buildPersonalViewConfig(objectDef.name, activeView, {
@@ -797,8 +799,6 @@ function ObjectViewInner({ dataSource, objects, onEdit, externalRefreshKey }: Co
     // one (`sys_personal_view` read and create), not to admins only; the name
     // is asked in `PersonalViewNameDialog`. A reader who cannot read the
     // list's own object is offered no Save: there is no list to keep.
-    const personalViewsReady = personalViews.status === 'ready';
-    const personalGrant = (action: 'create' | 'update') => !perms.isLoaded || perms.can(PERSONAL_VIEW_OBJECT, action);
     const listReadable = !perms.isLoaded || perms.can(objectDef.name, 'read');
     const [personalViewDialog, setPersonalViewDialog] = useState<{ mode: 'save' } | { mode: 'rename'; viewId: string } | null>(null);
     const openPersonalView = (id: string) => {
diff --git a/ui/packages/plugin-form/src/affordanceGrantMap-12082.test.tsx b/ui/packages/plugin-form/src/affordanceGrantMap-12082.test.tsx
index 4293a23fd38..cb0c4f2c8d2 100644
--- a/ui/packages/plugin-form/src/affordanceGrantMap-12082.test.tsx
+++ b/ui/packages/plugin-form/src/affordanceGrantMap-12082.test.tsx
@@ -739,6 +739,8 @@ const WRITE_SITES: Record<string, WriteSite> = {
     outOfFamily("the caller's OWN sys_personal_view row (Save as my view), offered behind perms.can(sys_personal_view, create) in ObjectView; the server keeps the rows owner-scoped; no record the caller browses is written"),
   'packages/app-shell/src/views/personalViews.ts :: usePersonalViews > rename :: update':
     outOfFamily("the caller's OWN sys_personal_view row (Rename), offered behind perms.can(sys_personal_view, update) in ObjectView; the server keeps the rows owner-scoped and fixes the owner; no record the caller browses is written"),
+  'packages/app-shell/src/views/personalViews.ts :: usePersonalViews > update :: update':
+    outOfFamily("the caller's OWN sys_personal_view row (保存, the list written back into the open personal view), offered behind the same perms.can(sys_personal_view, update) read as Rename in ObjectView; the server keeps the rows owner-scoped and fixes the owner; no record the caller browses is written"),
   // ── core ──
   'packages/core/src/actions/TransactionManager.ts :: TransactionManager > executeBatch :: batch':
     door('the action engine\'s transaction executor runs the operations its caller hands it'),