diff --git a/.changeset/28370-view-filter-or-group-console.md b/.changeset/28370-view-filter-or-group-console.md
new file mode 100644
index 00000000000..c25da838047
--- /dev/null
+++ b/.changeset/28370-view-filter-or-group-console.md
@@ -0,0 +1,21 @@
+---
+'@object-ui/core': patch
+'@object-ui/data-objectstack': patch
+'@object-ui/app-shell': patch
+'@object-ui/plugin-view': patch
+'@object-ui/i18n': patch
+---
+
+feat(console): a stored view filter's OR group filters the list, and the filter builder saves and reads it
+
+Clause-②: yes (widening: `@object-ui/core` adds the export `builderRulesOfSpecFilter` and its result type `BuilderFilterRules`; no schema, accept set or error code changes)
+Metadata-protocol: none
+Skills-docs: follow-up #28476 — skills/objectstack-ui/rules/list-views.md, skills/objectstack-ui/evals/views-apps-actions-pages.json (the any-of group is not taught there yet); `content/docs/ui/views.mdx` gains a Base filter section that states it
+
+A view filter list may hold an any-of group beside its rules, `{ or: [rule, ...] }` (`ViewFilterOrGroupSchema` in `@objectstack/spec/ui`): the list ANDs its elements and the group ORs its rules. Until now no console reader applied it. The list query passed the group through, the server refused the query as a malformed filter (400 `INVALID_FILTER`), and the view showed no rows.
+
+- **Query.** `toFilterNode` (`@object-ui/core`) lowers a group to an `or` node of its rules, one child of the list's AND, so the list, the export, kanban, calendar, gallery, timeline, related lists, line items, the grid and the in-memory `ValueDataSource` all select the records the group names. Each member is lowered exactly like a top-level rule, so the same operator fold and refusals apply inside a group. A group the spec refuses (an empty `or`, a blank-field member, a group inside a group) is not repaired: the server still refuses it.
+- **Adapter.** `@object-ui/data-objectstack` translates a group in an unlowered view filter list on both `find()` routes, whether it opens the list, follows a rule or is spread into an `and`. A group that does not translate is refused whole with `MalformedFilterError` (`INVALID_FILTER`, 400), never dropped.
+- **Save.** The filter builder's OR group over two or more rules is saved as one group element, `[{ or: rules }]`, instead of being refused with "a saved view cannot store OR". The `console.objectView.filterOrNotSavable` message is retired in all ten packs.
+- **Read back.** A stored list that is exactly one group opens in the Studio filter field, and in `toFilterGroup`, as an OR group of its rules. A list with a group beside other conditions cannot be shown by the one-level builder, so the Studio filter field shows it read-only with the reason (`console.objectView.filterOrGroupNotEditable`, in all ten packs) and never saves part of it.
+- **Override recovery.** The pass that drops unfinished conditions from a stored view override keeps a group, drops only its unfinished members, and drops a group with none left. It used to drop every group as an entry with no `field`, which widened the view.
diff --git a/content/docs/ui/views.mdx b/content/docs/ui/views.mdx
index 254b323f41d..4f376004d55 100644
--- a/content/docs/ui/views.mdx
+++ b/content/docs/ui/views.mdx
@@ -98,7 +98,7 @@ A List View controls how a collection of records is presented. It supports multi
 | `label` | `string` | optional | Display label shown in the view switcher |
 | `type` | `enum` | optional | View type (see table above; default `'grid'`) |
 | `data` | `ViewData` | optional | Data source configuration (defaults to the `object` provider) |
-| `filter` | `array` | optional | Base filter criteria |
+| `filter` | `array` | optional | Base filter: rules that all must match, any of which may be an any-of group `{ or: [...] }` — see [Base filter](#base-filter-filter) below |
 | `sort` | `array` | optional | Sort configuration |
 | `searchableFields` | `string[]` | optional | Fields the toolbar search scans — **narrows** the set the object allows, never widens it (ADR-0061). Every entry must be in that allowed set, or every toolbar search on the list returns `400 INVALID_FIELD` (#4254) — see [Toolbar search](#toolbar-search-searchablefields) below |
 | `grouping` | `object` | optional | Row grouping configuration |
@@ -115,6 +115,30 @@ The view's machine name is its **key** in the container (`listViews.urgent` on
 object `task` becomes `task.urgent`); the default `list` claims `task.default`.
 List and form views share that one namespace — don't reuse a key.
 
+### Base filter (`filter`)
+
+A list view's `filter` is a list of conditions that **all** must match. Each
+element is a rule `{ field, operator, value }`, or an **any-of group**
+`{ or: [rule, ...] }` that matches a record when **any** of its rules does. A
+group holds flat rules only (no group inside a group), and the list still ANDs
+the group with the elements beside it:
+
+```typescript
+// open, or completed in the last 7 days — and owned by me
+filter: [
+  { or: [
+    { field: 'status', operator: 'equals', value: 'open' },
+    { field: 'completed_at', operator: 'after', value: '{7_days_ago}' },
+  ] },
+  { field: 'owner', operator: 'equals', value: '{current_user_id}' },
+],
+```
+
+The Console's filter builder saves its **OR** toggle as one such group, and
+opens a filter that is exactly one group as an OR group. A filter whose group
+sits beside other conditions is applied to the list as written, but the
+builder shows it read-only, because it edits one AND or OR over flat rows.
+
 ### Toolbar search (`searchableFields`)
 
 The toolbar's search box scans a set the **object** owns. A list view's
diff --git a/ui/packages/app-shell/src/views/metadata-admin/inspectors/PageBlockInspector.tsx b/ui/packages/app-shell/src/views/metadata-admin/inspectors/PageBlockInspector.tsx
index 4885e6448e4..6b15d9dbc68 100644
--- a/ui/packages/app-shell/src/views/metadata-admin/inspectors/PageBlockInspector.tsx
+++ b/ui/packages/app-shell/src/views/metadata-admin/inspectors/PageBlockInspector.tsx
@@ -59,15 +59,18 @@ function useFieldOptions(objectName: string | undefined): Array<{ value: string;
   );
 }
 
+/** The elements `FilterBuilderField` reads and writes. */
+type FilterElements = NonNullable<React.ComponentProps<typeof FilterBuilderField>['value']>;
+
 /**
- * A block prop that is a spec `ViewFilterRule[]` (`record:related_list.filter`),
- * edited with the list toolbar's own filter builder — the one the
+ * A block prop that is a spec view filter list (`record:related_list.filter`:
+ * flat rules, any of which may be an any-of group `{ or: [rule, ...] }`), edited with the list toolbar's own filter builder — the one the
  * `filter-builder` form widget renders for a view's and a page's filters — over
  * the fields of `objectName`. Clearing the last rule removes the key.
  */
 function FilterRulesField({ label, objectName, value, onChange, disabled }: {
   label: string; objectName: string | undefined; value: unknown;
-  onChange: (v: Array<{ field: string; operator: string; value?: unknown }> | undefined) => void;
+  onChange: (v: FilterElements | undefined) => void;
   disabled?: boolean;
 }) {
   const { fields, error } = useObjectFields(objectName);
@@ -81,7 +84,7 @@ function FilterRulesField({ label, objectName, value, onChange, disabled }: {
       <Label htmlFor={id} className="text-xs text-muted-foreground">{label}</Label>
       <FilterBuilderField
         id={id}
-        value={Array.isArray(value) ? (value as Array<{ field: string; operator: string; value?: unknown }>) : undefined}
+        value={Array.isArray(value) ? (value as FilterElements) : undefined}
         onChange={(rules) => onChange(rules.length > 0 ? rules : undefined)}
         fields={builderFields}
         readOnly={disabled}
diff --git a/ui/packages/app-shell/src/views/metadata-admin/widgets.tsx b/ui/packages/app-shell/src/views/metadata-admin/widgets.tsx
index be60ad2802c..705370d5dba 100644
--- a/ui/packages/app-shell/src/views/metadata-admin/widgets.tsx
+++ b/ui/packages/app-shell/src/views/metadata-admin/widgets.tsx
@@ -42,6 +42,7 @@ import {
   DialogTitle,
 } from '@object-ui/components';
 import type { RegistryComponentMeta } from '@object-ui/core';
+import { builderRulesOfSpecFilter } from '@object-ui/core';
 import { AlertTriangle, ChevronDown, ChevronsUpDown, ChevronUp, Eye, EyeOff, Plus, Search, Trash2 } from 'lucide-react';
 import { iconNames } from 'lucide-react/dynamic.mjs';
 import { toast } from 'sonner';
@@ -2586,7 +2587,7 @@ function FilterModeWidget({ value, onChange, readOnly, context, ariaLabelledBy }
               {/* Per-tab filter — unified runtime FilterBuilder (popover). */}
               <div className="pl-1" data-testid={`tab-${ti}-filter`}>
                 <FilterBuilderField
-                  value={tab.filter as FilterRuleLite[] | undefined}
+                  value={tab.filter as FilterElementLite[] | undefined}
                   onChange={(f) => patchTab(ti, { filter: f as any })}
                   fields={objectFields}
                   loadError={loadError}
@@ -2737,11 +2738,31 @@ function ActionMultiWidget({ value, onChange, readOnly, context, ariaLabelledBy
 
 interface FilterRuleLite { field: string; operator: string; value?: unknown }
 
-/** The builder's row group for a stored rule list. */
-function groupOfStoredRules(rules: FilterRuleLite[]) {
+/**
+ * One element of a stored view filter list: a flat rule, or an any-of group
+ * `{ or: [rule, ...] }` (`ViewFilterOrGroupSchema`), which is what the fold
+ * writes for an OR group.
+ */
+type FilterElementLite = FilterRuleLite | { or: FilterRuleLite[] };
+
+/** Every flat rule of a stored list, a group's members included, for the summary. */
+function rulesOfStoredElements(elements: FilterElementLite[]): FilterRuleLite[] {
+  return elements.flatMap((element) => {
+    const members = (element as { or?: unknown }).or;
+    return Array.isArray(members) ? (members as FilterRuleLite[]) : [element as FilterRuleLite];
+  });
+}
+
+/**
+ * The builder's row group for a stored list the builder can show
+ * (`builderRulesOfSpecFilter`): its ONE logic over its flat rules, so an OR
+ * group the fold wrote reads back as the OR group it was.
+ */
+function groupOfStoredRules(shown: { logic: 'and' | 'or'; rules: unknown[] } | null) {
+  const rules = (shown?.rules ?? []) as FilterRuleLite[];
   return {
     id: 'g',
-    logic: 'and' as const,
+    logic: shown?.logic ?? ('and' as const),
     conditions: rules.map((r, i) => ({
       id: `c${i}`,
       // Handed over as stored: the builder reads it through the spec's fold
@@ -2755,8 +2776,8 @@ function groupOfStoredRules(rules: FilterRuleLite[]) {
 }
 
 export function FilterBuilderField({ value, onChange, fields, readOnly, id, ariaLabelledBy, loadError }: {
-  value?: FilterRuleLite[];
-  onChange: (rules: FilterRuleLite[]) => void;
+  value?: FilterElementLite[];
+  onChange: (rules: FilterElementLite[]) => void;
   fields: Array<{ name: string; label?: string; type?: string; options?: Array<{ value: string; label: string }> }>;
   readOnly?: boolean;
   /**
@@ -2786,6 +2807,12 @@ export function FilterBuilderField({ value, onChange, fields, readOnly, id, aria
   // platform translator (same one ObjectView's toolbar toasts use).
   const { t: tr } = useObjectTranslation();
   const rules = Array.isArray(value) ? value : [];
+  // The stored list as the builder's one logic over flat rows, or `null` when
+  // it holds an any-of group beside other elements: the builder edits one
+  // logic, so loading that list would drop part of it on the next save. Such a
+  // list is shown, never edited, here.
+  const shown = builderRulesOfSpecFilter(rules);
+  const notEditable = shown === null;
   // The stored rules by CONTENT, so a re-render handing over an equal array is
   // not a change (ui/AGENTS.md #10: never key on an identity).
   const rulesKey = JSON.stringify(rules);
@@ -2796,7 +2823,7 @@ export function FilterBuilderField({ value, onChange, fields, readOnly, id, aria
   // the rows from the stored rules therefore erased the new row on the next
   // render, so no filter could be authored here at all. The held group keeps
   // such a row on screen until it is complete; only the fold's rules leave.
-  const [draft, setDraft] = React.useState(() => groupOfStoredRules(rules));
+  const [draft, setDraft] = React.useState(() => groupOfStoredRules(shown));
   const [seededFrom, setSeededFrom] = React.useState(rulesKey);
   if (seededFrom !== rulesKey) {
     // The stored rules moved. When they are the echo of this builder's own
@@ -2804,7 +2831,7 @@ export function FilterBuilderField({ value, onChange, fields, readOnly, id, aria
     // editor, a reload, an undo) re-seeds the rows from what is stored.
     setSeededFrom(rulesKey);
     const held = foldFilterGroupToSpecRules(draft);
-    if (!held.ok || JSON.stringify(held.rules) !== rulesKey) setDraft(groupOfStoredRules(rules));
+    if (!held.ok || JSON.stringify(held.rules) !== rulesKey) setDraft(groupOfStoredRules(shown));
   }
   // `options` travel with the column (objectstack#27515): the builder draws a
   // picklist column's value as a picker over them and stores the option's
@@ -2817,14 +2844,16 @@ export function FilterBuilderField({ value, onChange, fields, readOnly, id, aria
     type: f.type,
     ...(f.options ? { options: f.options } : {}),
   }));
-  const summary = rules.length
-    ? rules.map((r) => `${fields.find((f) => f.name === r.field)?.label || r.field}`).filter(Boolean).join(', ')
+  const storedRules = rulesOfStoredElements(rules);
+  const summary = storedRules.length
+    ? storedRules.map((r) => `${fields.find((f) => f.name === r.field)?.label || r.field}`).filter(Boolean).join(', ')
     : '';
   const handle = (g: any) => {
-    // Shared with the runtime list toolbar (objectstack#5159). A group that
-    // cannot fold losslessly — `logic: 'or'` over several rows, or a nested
-    // group — is refused rather than silently written as AND, which is what
-    // this callback used to do by dropping `g.logic` on the floor.
+    // Shared with the runtime list toolbar (objectstack#5159). An OR group
+    // folds to one any-of element (`{ or: rules }`); a group that cannot fold
+    // losslessly — a nested group — is refused rather than silently written as
+    // something else, which is what this callback used to do by dropping
+    // `g.logic` on the floor.
     const folded = foldFilterGroupToSpecRules(g);
     if (!folded.ok) {
       toast.error(tr(FILTER_FOLD_REFUSAL_KEYS[folded.reason]));
@@ -2834,7 +2863,7 @@ export function FilterBuilderField({ value, onChange, fields, readOnly, id, aria
     // A row added or edited without completing it folds to the rules already
     // stored: the view has not changed, so nothing is written.
     if (JSON.stringify(folded.rules) === rulesKey) return;
-    onChange(folded.rules as FilterRuleLite[]);
+    onChange(folded.rules as FilterElementLite[]);
   };
   return (
     <Popover>
@@ -2843,7 +2872,8 @@ export function FilterBuilderField({ value, onChange, fields, readOnly, id, aria
           role `button` — axe-core reports it as `aria-allowed-attr`. The other
           ten `'control'` widgets carry it through `controlNaming`. */}
       <PopoverTrigger asChild>
-        <Button {...controlNaming({ id, ariaLabelledBy })} variant="outline" size="sm" disabled={readOnly}
+        <Button {...controlNaming({ id, ariaLabelledBy })} variant="outline" size="sm" disabled={readOnly || notEditable}
+          title={notEditable ? tr('console.objectView.filterOrGroupNotEditable') : undefined}
           className="h-8 w-full justify-between text-xs font-normal" data-testid="filter-builder-trigger">
           <span className="truncate text-left">{summary || <span className="text-muted-foreground">+ Add filter…</span>}</span>
           <ChevronDown className="h-3.5 w-3.5 opacity-60 shrink-0" />
@@ -2875,7 +2905,7 @@ function FilterBuilderWidget({ id, ariaLabelledBy, value, onChange, readOnly, co
     <FilterBuilderField
       id={id}
       ariaLabelledBy={ariaLabelledBy}
-      value={value as FilterRuleLite[] | undefined}
+      value={value as FilterElementLite[] | undefined}
       onChange={(rules) => onChange(rules.length ? rules : undefined)}
       fields={fields}
       loadError={loadError}
diff --git a/ui/packages/app-shell/src/views/objectViewTabs.ts b/ui/packages/app-shell/src/views/objectViewTabs.ts
index 2a8e82a9436..5544e7b1da0 100644
--- a/ui/packages/app-shell/src/views/objectViewTabs.ts
+++ b/ui/packages/app-shell/src/views/objectViewTabs.ts
@@ -9,7 +9,7 @@ import { leadWithNameField } from '@object-ui/core';
 import { isFilterValueComplete } from '@object-ui/components';
 import { isSystemManagedField } from '@object-ui/types';
 import { narrowPersonalizationOverlay } from '@object-ui/data-objectstack';
-import { ListViewSchema as SpecListViewSchema, normalizeFilterOperator, VIEW_CONSOLE_ROUND_TRIP_KEYS } from '@objectstack/spec/ui';
+import { isViewFilterOrGroup, ListViewSchema as SpecListViewSchema, normalizeFilterOperator, VIEW_CONSOLE_ROUND_TRIP_KEYS } from '@objectstack/spec/ui';
 import { VALUELESS_FILTER_OPERATORS } from './viewFilterFold.js';
 import { viewEnvelope, type ViewEnvelope } from './runtime-metadata-persistence.js';
 import { buildNewViewSpec } from './newViewSpec.js';
@@ -246,19 +246,38 @@ export function sanitizeViewOverride(override: any): any {
     // Folded before the lookup — see the docblock (objectui#9306).
     const isValueless = (operator: unknown): boolean =>
         VALUELESS_FILTER_OPERATORS.has(normalizeFilterOperator(String(operator)));
-    const kept = override.filter.filter((entry: any) => {
-        if (Array.isArray(entry)) {
-            // Legacy runtime triple: [field, operator, value]
-            if (entry.length < 2) return false;
-            const [, operator, value] = entry;
-            if (isValueless(operator)) return true;
-            return isFilterValueComplete(String(operator), value);
-        }
+    const isEffectiveRule = (entry: any): boolean => {
         if (!entry || typeof entry !== 'object') return false;
         if (typeof entry.field !== 'string' || entry.field === '') return false;
         if (isValueless(entry.operator)) return true;
         const value = entry.value;
         return isFilterValueComplete(String(entry.operator), value);
+    };
+    let changed = false;
+    const kept = override.filter.flatMap((entry: any) => {
+        if (Array.isArray(entry)) {
+            // Legacy runtime triple: [field, operator, value]
+            const effective = entry.length >= 2
+                && (isValueless(entry[1]) || isFilterValueComplete(String(entry[1]), entry[2]));
+            if (!effective) changed = true;
+            return effective ? [entry] : [];
+        }
+        // An any-of group (`{ or: [rule, ...] }`, objectstack#28020) is judged
+        // by its members, the way the live query reads an OR group's rows: an
+        // unfinished member is not a condition, so it leaves the group, and a
+        // group with no effective member left carries no condition at all. A
+        // group whose `or` is not an array is kept as it is, so the server's
+        // refusal of that shape is still what the author sees.
+        if (isViewFilterOrGroup(entry)) {
+            if (!Array.isArray(entry.or)) return [entry];
+            const members = entry.or.filter(isEffectiveRule);
+            if (members.length === entry.or.length) return [entry];
+            changed = true;
+            return members.length > 0 ? [{ ...entry, or: members }] : [];
+        }
+        const effective = isEffectiveRule(entry);
+        if (!effective) changed = true;
+        return effective ? [entry] : [];
     });
 
     // The empty-array case is checked FIRST: `filter: []` (Clear all's write)
@@ -273,7 +292,7 @@ export function sanitizeViewOverride(override: any): any {
         const { filter: _dropped, ...rest } = override;
         return rest;
     }
-    if (kept.length === override.filter.length) return override;
+    if (!changed) return override;
     return { ...override, filter: kept };
 }
 
diff --git a/ui/packages/app-shell/src/views/studio-design/ObjectListViewInspector.tsx b/ui/packages/app-shell/src/views/studio-design/ObjectListViewInspector.tsx
index 4d160fd4359..3b6fdbda3e6 100644
--- a/ui/packages/app-shell/src/views/studio-design/ObjectListViewInspector.tsx
+++ b/ui/packages/app-shell/src/views/studio-design/ObjectListViewInspector.tsx
@@ -705,7 +705,14 @@ function fieldNamesHeldBy(body: Row): string[] {
     if (typeof name === 'string' && name) held.add(name);
   };
   if (Array.isArray(body.columns)) for (const column of body.columns) add(colFieldName(column));
-  if (Array.isArray(body.filter)) for (const rule of body.filter) if (isPlainObject(rule)) add(rule.field);
+  if (Array.isArray(body.filter)) {
+    for (const element of body.filter) {
+      if (!isPlainObject(element)) continue;
+      // An any-of group's members are rules too (`{ or: [rule, ...] }`).
+      if (Array.isArray(element.or)) element.or.forEach((rule: unknown) => { if (isPlainObject(rule)) add(rule.field); });
+      else add(element.field);
+    }
+  }
   for (const entry of sortEntriesOf(body.sort)) add(entry.field);
   if (isPlainObject(body.kanban)) {
     if (Array.isArray(body.kanban.columns)) body.kanban.columns.forEach(add);
diff --git a/ui/packages/app-shell/src/views/viewFilterFold.test.ts b/ui/packages/app-shell/src/views/viewFilterFold.test.ts
index b2176570c35..0b3ebffdce1 100644
--- a/ui/packages/app-shell/src/views/viewFilterFold.test.ts
+++ b/ui/packages/app-shell/src/views/viewFilterFold.test.ts
@@ -17,6 +17,7 @@
  */
 import { describe, it, expect } from 'vitest';
 import { ListViewSchema } from '@objectstack/spec/ui';
+import type { ViewFilterRule } from '@objectstack/spec/ui';
 import { foldFilterGroupToSpecRules, FILTER_FOLD_REFUSAL_KEYS } from './viewFilterFold';
 
 /**
@@ -119,7 +120,8 @@ describe('foldFilterGroupToSpecRules — flat AND group → ViewFilterRule[]', (
             })),
         });
         expect(result.ok).toBe(true);
-        expect(result.ok && result.rules.map(r => r.operator)).toEqual([
+        // An AND group folds to flat rules only, so each element is a rule here.
+        expect(result.ok && result.rules.map(r => (r as ViewFilterRule).operator)).toEqual([
             'equals', 'not_equals', 'contains', 'not_contains',
             'is_empty', 'is_not_empty', 'greater_than', 'less_than',
             'greater_than_or_equal', 'less_than_or_equal', 'before', 'after', 'between',
@@ -133,7 +135,7 @@ describe('foldFilterGroupToSpecRules — flat AND group → ViewFilterRule[]', (
             conditions: [{ id: 'a', field: 'f', operator: 'sounds_like', value: 'x' }],
         });
         // NOT silently rewritten to `equals` — the spec enum is the judge.
-        expect(result.ok && result.rules[0].operator).toBe('sounds_like');
+        expect(result.ok && (result.rules[0] as ViewFilterRule).operator).toBe('sounds_like');
     });
 
     it('drops the blank row `Add filter` inserts before a column is picked', () => {
@@ -179,8 +181,8 @@ describe('foldFilterGroupToSpecRules — empty conditions', () => {
     });
 });
 
-describe('foldFilterGroupToSpecRules — loud refusal, never a silent downgrade (A1)', () => {
-    it("refuses `logic: 'or'` over two conditions instead of writing them as AND", () => {
+describe('foldFilterGroupToSpecRules — OR folds to a group; nesting is a loud refusal, never a silent downgrade (A1)', () => {
+    it("folds `logic: 'or'` over two conditions to ONE any-of group, never to AND (objectstack#28370)", () => {
         const result = foldFilterGroupToSpecRules({
             id: 'root',
             logic: 'or',
@@ -189,13 +191,18 @@ describe('foldFilterGroupToSpecRules — loud refusal, never a silent downgrade
                 { id: 'b', field: 'status', operator: 'equals', value: 'blocked' },
             ],
         });
-        expect(result).toEqual({ ok: false, reason: 'or_logic' });
-        // The refusal reaches the user through a translated string, not a
-        // console throw: the toolbar surfaces this key as a toast.
-        expect(FILTER_FOLD_REFUSAL_KEYS.or_logic).toBe('console.objectView.filterOrNotSavable');
+        expect(result).toEqual({
+            ok: true,
+            rules: [{ or: [
+                { field: 'status', operator: 'equals', value: 'open' },
+                { field: 'status', operator: 'equals', value: 'blocked' },
+            ] }],
+        });
+        // OR is no longer a refusal reason: only nesting is.
+        expect(Object.keys(FILTER_FOLD_REFUSAL_KEYS)).toEqual(['nested_group']);
     });
 
-    it('refuses OR however many conditions there are beyond one', () => {
+    it('folds OR over three conditions into the one group, in row order', () => {
         const result = foldFilterGroupToSpecRules({
             id: 'root', logic: 'or',
             conditions: [
@@ -204,7 +211,11 @@ describe('foldFilterGroupToSpecRules — loud refusal, never a silent downgrade
                 { id: 'c', field: 'c', operator: 'equals', value: 3 },
             ],
         });
-        expect(result.ok).toBe(false);
+        expect(result.ok && result.rules).toEqual([{ or: [
+            { field: 'a', operator: 'equals', value: 1 },
+            { field: 'b', operator: 'equals', value: 2 },
+            { field: 'c', operator: 'equals', value: 3 },
+        ] }]);
     });
 
     it("folds `logic: 'or'` over ONE condition — OR and AND select the same records there", () => {
@@ -245,7 +256,7 @@ describe('foldFilterGroupToSpecRules — loud refusal, never a silent downgrade
     });
 
     it('every refusal reason has a user-readable key — no reason can surface untranslated', () => {
-        const reasons: Array<keyof typeof FILTER_FOLD_REFUSAL_KEYS> = ['or_logic', 'nested_group'];
+        const reasons: Array<keyof typeof FILTER_FOLD_REFUSAL_KEYS> = ['nested_group'];
         for (const reason of reasons) {
             expect(FILTER_FOLD_REFUSAL_KEYS[reason]).toMatch(/^console\.objectView\./);
         }
diff --git a/ui/packages/app-shell/src/views/viewFilterFold.ts b/ui/packages/app-shell/src/views/viewFilterFold.ts
index 0f278c8c9b9..c706963c97b 100644
--- a/ui/packages/app-shell/src/views/viewFilterFold.ts
+++ b/ui/packages/app-shell/src/views/viewFilterFold.ts
@@ -14,7 +14,8 @@
  * spec's own canonical spellings since objectui#9306 (they were camelCase
  * before, and a group read from older storage may still carry those).
  * `@objectstack/spec`'s `ListViewSchema.filter` / `ViewTab.filter` declare
- * `z.array(ViewFilterRuleSchema)`: a FLAT list of `{ field, operator, value }`.
+ * `z.array(ViewFilterElementSchema)`: an AND list of flat `{ field, operator,
+ * value }` rules, any element of which may be an any-of group `{ or: [rule, ...] }`.
  * Persisting the builder's group verbatim is a type error the server rejects
  * with a `invalid_union` 422 — objectstack#5159, reproduced in a real browser
  * on the list toolbar's `Filter → Add filter → save`.
@@ -32,18 +33,16 @@
  */
 
 import { normalizeFilterOperator } from '@objectstack/spec/ui';
-import type { ViewFilterRule } from '@objectstack/spec/ui';
+import type { ViewFilterElement, ViewFilterRule } from '@objectstack/spec/ui';
 import { VALUELESS_FILTER_BUILDER_OPERATORS, isFilterValueComplete } from '@object-ui/components';
 
-/** Why a group could not be folded to a flat spec rule list. */
+/** Why a group could not be folded to a spec view filter list. */
 export type FilterFoldRefusal =
-    /** `logic: 'or'` over 2+ conditions — a flat rule array is AND-only. */
-    | 'or_logic'
-    /** A condition that is itself a group — the spec rule list has no nesting. */
+    /** A condition that is itself a group — the builder edits one level only. */
     | 'nested_group';
 
 export type FilterFoldResult =
-    | { ok: true; rules: ViewFilterRule[] }
+    | { ok: true; rules: ViewFilterElement[] }
     | { ok: false; reason: FilterFoldRefusal };
 
 /** Loose shape of what the FilterBuilder hands back through `onChange`. */
@@ -184,15 +183,16 @@ function isGroupLike(value: unknown): value is FilterGroupLike {
  *   and is kept; only a row that WANTS a
  *   value and has none is dropped.
  *
- * Refusals (objectstack#5159, maintainer adjudication A1): a shape that cannot
- * fold LOSSLESSLY is refused, never downgraded. `logic: 'or'` has no at-rest
- * representation in a flat rule array, so quietly writing those conditions as
- * AND would return a different record set than the one on screen.
+ * - **`logic: 'or'` over two or more rules folds to ONE any-of group
+ *   element**, `[{ or: rules }]` (`ViewFilterOrGroupSchema`, objectstack#28020):
+ *   the list ANDs its elements and the group ORs its rules, so the stored view
+ *   selects the records on screen. Over fewer than two rules OR and AND select
+ *   the same records, so the rules are written flat, as an AND group's are.
  *
- * `logic: 'or'` over FEWER than two effective rules is folded rather than
- * refused: with 0 or 1 condition, OR and AND select exactly the same records,
- * so there is nothing to lose and nothing to downgrade. The refusal starts
- * where the semantics actually diverge.
+ * Refusals (objectstack#5159, maintainer adjudication A1): a shape that cannot
+ * fold LOSSLESSLY is refused, never downgraded. A nested group has no at-rest
+ * representation (the any-of group holds flat rules only), so it is refused
+ * rather than written as something that returns a different record set.
  */
 export function foldFilterGroupToSpecRules(group: unknown): FilterFoldResult {
     if (group == null) return { ok: true, rules: [] };
@@ -225,13 +225,12 @@ export function foldFilterGroupToSpecRules(group: unknown): FilterFoldResult {
     }
 
     const logic = isGroupLike(group) ? group.logic : undefined;
-    if (logic === 'or' && rules.length > 1) return { ok: false, reason: 'or_logic' };
+    if (logic === 'or' && rules.length > 1) return { ok: true, rules: [{ or: rules }] };
 
     return { ok: true, rules };
 }
 
 /** i18n key carrying the user-readable refusal for each {@link FilterFoldRefusal}. */
 export const FILTER_FOLD_REFUSAL_KEYS: Record<FilterFoldRefusal, string> = {
-    or_logic: 'console.objectView.filterOrNotSavable',
     nested_group: 'console.objectView.filterNestedNotSavable',
 };
diff --git a/ui/packages/app-shell/src/views/viewFilterOrGroup.roundTrip-28370.test.tsx b/ui/packages/app-shell/src/views/viewFilterOrGroup.roundTrip-28370.test.tsx
new file mode 100644
index 00000000000..18b6298ccb7
--- /dev/null
+++ b/ui/packages/app-shell/src/views/viewFilterOrGroup.roundTrip-28370.test.tsx
@@ -0,0 +1,174 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#28370 — the filter builder SAVES an OR group as one any-of group
+ * element, `{ or: [rule, ...] }` (`ViewFilterOrGroupSchema`), and READS a
+ * stored group back as the OR group it was.
+ *
+ * The fold used to refuse an OR group (`or_logic`): a flat rule list had no OR
+ * spelling. Pinned here:
+ *
+ *  - fold → spec → read: the folded body is accepted by `ListViewSchema`, and
+ *    `toFilterGroup` (over `parseSpecFilter`) reads it back as an OR group that folds
+ *    to the same body;
+ *  - the Studio `filter-builder` widget shows a stored group as an OR group,
+ *    writes an OR toggle as one group, and shows a group beside other
+ *    conditions read-only, so no save can drop part of it;
+ *  - the view-override recovery pass (`sanitizeViewOverride`) keeps a group
+ *    instead of dropping it as an entry with no `field`.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { ListViewSchema } from '@objectstack/spec/ui';
+import { toFilterGroup } from '@object-ui/plugin-view';
+import { foldFilterGroupToSpecRules } from './viewFilterFold';
+import { sanitizeViewOverride } from './objectViewTabs';
+import { WIDGETS } from './metadata-admin/widgets';
+import { loaded } from './metadata-admin/loadState';
+
+// The builder lives inside a Radix popover, which does not open in jsdom; the
+// popover parts render inline, as in `widgets.filterBuilderHeldRow-26738.test.tsx`.
+vi.mock('@object-ui/components', async () => {
+  const actual = await vi.importActual<Record<string, unknown>>('@object-ui/components');
+  const Pass = ({ children }: { children?: unknown }) => children as never;
+  return { ...actual, Popover: Pass, PopoverTrigger: Pass, PopoverContent: Pass };
+});
+
+afterEach(cleanup);
+
+const OPEN = { field: 'status', operator: 'equals', value: 'open' };
+const DRAFT = { field: 'title', operator: 'equals', value: 'draft' };
+const OR_GROUP = { or: [OPEN, DRAFT] };
+
+const viewBody = (filter: unknown) => ({ name: 'default', label: 'All', type: 'grid', columns: ['title'], filter });
+
+describe('an OR group folds to one { or } element and reads back as an OR group (objectstack#28370)', () => {
+  const builderGroup = {
+    id: 'root',
+    logic: 'or',
+    conditions: [
+      { id: 'a', ...OPEN },
+      { id: 'b', ...DRAFT },
+    ],
+  };
+
+  it('the fold writes one any-of group, which ListViewSchema accepts', () => {
+    const folded = foldFilterGroupToSpecRules(builderGroup);
+    expect(folded).toEqual({ ok: true, rules: [OR_GROUP] });
+    const parsed = ListViewSchema.safeParse(viewBody(folded.ok ? folded.rules : undefined));
+    expect(parsed.success, JSON.stringify((parsed as { error?: unknown }).error)).toBe(true);
+  });
+
+  it('toFilterGroup reads the stored group back as an OR group of its rules', () => {
+    const parsed = toFilterGroup([OR_GROUP]);
+    expect(parsed.logic).toBe('or');
+    expect(parsed.conditions.map(({ field, operator, value }) => ({ field, operator, value }))).toEqual([OPEN, DRAFT]);
+  });
+
+  it('round trip: what the builder reads back folds to the body that was stored', () => {
+    const stored = foldFilterGroupToSpecRules(builderGroup);
+    expect(stored.ok).toBe(true);
+    const reread = toFilterGroup(stored.ok ? stored.rules : []);
+    expect(reread.logic).toBe('or');
+    expect(foldFilterGroupToSpecRules(reread)).toEqual(stored);
+  });
+
+  it('CONTROL: an AND group still folds flat and reads back as AND', () => {
+    const folded = foldFilterGroupToSpecRules({ ...builderGroup, logic: 'and' });
+    expect(folded).toEqual({ ok: true, rules: [OPEN, DRAFT] });
+    expect(toFilterGroup([OPEN, DRAFT]).logic).toBe('and');
+  });
+});
+
+type Elements = unknown[];
+const FilterWidget = WIDGETS['filter-builder'];
+const FIELDS = loaded([
+  { name: 'title', label: 'Title', type: 'text' },
+  { name: 'status', label: 'Status', type: 'text' },
+  { name: 'owner', label: 'Owner', type: 'text' },
+]);
+
+function Host({ initial, writes }: { initial?: Elements; writes: Array<Elements | undefined> }) {
+  const [filter, setFilter] = React.useState<Elements | undefined>(initial);
+  return (
+    <>
+      <FilterWidget
+        schema={{}}
+        value={filter}
+        context={{ conditionScope: 'none', objectFields: FIELDS }}
+        onChange={(next) => {
+          writes.push(next as Elements | undefined);
+          setFilter(next as Elements | undefined);
+        }}
+      />
+      <pre data-testid="stored-filter">{JSON.stringify(filter ?? null)}</pre>
+    </>
+  );
+}
+
+const storedFilter = () => JSON.parse(screen.getByTestId('stored-filter').textContent ?? 'null');
+const valueInputs = () => screen.queryAllByPlaceholderText('Value') as HTMLInputElement[];
+
+describe('the Studio filter-builder widget reads and writes an OR group (objectstack#28370)', () => {
+  it('a stored group shows as an OR group of its rows, and an edit writes the group back', () => {
+    const writes: Array<Elements | undefined> = [];
+    render(<Host initial={[OR_GROUP]} writes={writes} />);
+
+    expect(valueInputs().map((input) => input.value)).toEqual(['open', 'draft']);
+    expect(screen.getByTestId('filter-logic-toggle')).toHaveTextContent('OR');
+    expect(screen.getByTestId('filter-builder-trigger')).toHaveTextContent('Status, Title');
+    expect(screen.getByTestId('filter-builder-trigger')).toBeEnabled();
+    expect(writes).toEqual([]);
+
+    fireEvent.change(valueInputs()[1], { target: { value: 'final' } });
+    expect(writes.at(-1)).toEqual([{ or: [OPEN, { ...DRAFT, value: 'final' }] }]);
+  });
+
+  it('switching a stored AND list to OR writes one group, and back to AND writes it flat', () => {
+    const writes: Array<Elements | undefined> = [];
+    render(<Host initial={[OPEN, DRAFT]} writes={writes} />);
+    expect(screen.getByTestId('filter-logic-toggle')).toHaveTextContent('AND');
+
+    fireEvent.click(screen.getByTestId('filter-logic-toggle'));
+    expect(storedFilter()).toEqual([OR_GROUP]);
+
+    fireEvent.click(screen.getByTestId('filter-logic-toggle'));
+    expect(storedFilter()).toEqual([OPEN, DRAFT]);
+  });
+
+  it('a group beside another condition is shown read-only, never loaded into the one-level builder', () => {
+    const writes: Array<Elements | undefined> = [];
+    const mixed = [OR_GROUP, { field: 'owner', operator: 'equals', value: 'u1' }];
+    render(<Host initial={mixed} writes={writes} />);
+
+    const trigger = screen.getByTestId('filter-builder-trigger');
+    expect(trigger).toBeDisabled();
+    // The reason, through the console packs (no provider here, so the key).
+    expect(trigger.getAttribute('title')).toBe('console.objectView.filterOrGroupNotEditable');
+    // Every field the list holds is named, the group's members included.
+    expect(trigger).toHaveTextContent('Status, Title, Owner');
+    expect(writes).toEqual([]);
+    expect(storedFilter()).toEqual(mixed);
+  });
+});
+
+describe('sanitizeViewOverride keeps an OR group (objectstack#28370)', () => {
+  it('a complete group is kept as stored', () => {
+    const override = { id: 'v', filter: [OR_GROUP] };
+    expect(sanitizeViewOverride(override)).toBe(override);
+  });
+
+  it('an unfinished member leaves the group, and the rest of the group stays', () => {
+    const unfinished = { field: 'title', operator: 'equals', value: '' };
+    expect(sanitizeViewOverride({ id: 'v', filter: [{ or: [OPEN, unfinished] }] }))
+      .toEqual({ id: 'v', filter: [{ or: [OPEN] }] });
+  });
+
+  it('a group with no finished member carries no condition, so the source filter wins again', () => {
+    const unfinished = { field: 'title', operator: 'equals', value: '' };
+    expect(sanitizeViewOverride({ id: 'v', filter: [{ or: [unfinished] }] })).toEqual({ id: 'v' });
+  });
+});
diff --git a/ui/packages/core/src/utils/__tests__/view-filter-or-group-28370.test.ts b/ui/packages/core/src/utils/__tests__/view-filter-or-group-28370.test.ts
new file mode 100644
index 00000000000..32043910862
--- /dev/null
+++ b/ui/packages/core/src/utils/__tests__/view-filter-or-group-28370.test.ts
@@ -0,0 +1,157 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectstack#28370 — a stored view filter list's any-of group element,
+ * `{ or: [rule, ...] }` (`@objectstack/spec/ui` `ViewFilterOrGroupSchema`), is
+ * LOWERED by the console's one sink, `toFilterNode`, to an `or` node of its
+ * rules inside the list's AND.
+ *
+ * Before it, `toFilterNode` passed a group through untouched: an object in AST
+ * position, which `isFilterAST` refuses, so the server answered
+ * `400 INVALID_FILTER` and the list showed no rows. Every assertion here is the
+ * node that reaches the wire put through the spec's own doors
+ * (`isFilterAST` / `parseFilterAST`), or the ROW SET a real `ValueDataSource`
+ * returns for it — never the source text.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { isFilterAST, parseFilterAST } from '@objectstack/spec/data';
+import { ViewFilterElementSchema } from '@objectstack/spec/ui';
+import {
+  builderRulesOfSpecFilter,
+  FilterOperatorError,
+  mergeFilterNodes,
+  toFilterNode,
+  toFilterNodeSafely,
+} from '../filter-converter';
+import { ValueDataSource } from '../../adapters/ValueDataSource';
+
+const OPEN = { field: 'status', operator: 'equals', value: 'open' } as const;
+const BLOCKED = { field: 'status', operator: 'equals', value: 'blocked' } as const;
+const MINE = { field: 'owner', operator: 'equals', value: 'u1' } as const;
+
+type Row = { id: string; status: string; owner: string; done_at: number };
+const ROWS: Row[] = [
+  { id: 'a', status: 'open', owner: 'u1', done_at: 0 },
+  { id: 'b', status: 'blocked', owner: 'u1', done_at: 0 },
+  { id: 'c', status: 'done', owner: 'u1', done_at: 9 },
+  { id: 'd', status: 'done', owner: 'u1', done_at: 1 },
+  { id: 'e', status: 'open', owner: 'u2', done_at: 0 },
+];
+const ALL_IDS = ROWS.map((r) => r.id);
+
+async function selectedIds(filter: unknown): Promise<string[]> {
+  const ds = new ValueDataSource<Row>({ items: ROWS });
+  const res = await ds.find('t', { $filter: filter as never });
+  return (res.data as Row[]).map((r) => r.id);
+}
+
+describe('toFilterNode lowers an any-of group to an `or` node (objectstack#28370)', () => {
+  it('the fixtures are spec-valid elements, so the cases below are what an author can store', () => {
+    for (const element of [{ or: [OPEN, BLOCKED] }, MINE]) {
+      const parsed = ViewFilterElementSchema.safeParse(element);
+      expect(parsed.success, JSON.stringify((parsed as { error?: unknown }).error)).toBe(true);
+    }
+  });
+
+  it('a list that is one group lowers to one `or` node of its rules', () => {
+    const node = toFilterNode([{ or: [OPEN, BLOCKED] }]);
+    expect(node).toEqual([['or', ['status', 'equals', 'open'], ['status', 'equals', 'blocked']]]);
+    expect(isFilterAST(node)).toBe(true);
+    expect(parseFilterAST(node as never)).toEqual({
+      $or: [{ status: 'open' }, { status: 'blocked' }],
+    });
+  });
+
+  it('a group beside a plain rule is one child of the list AND', () => {
+    const node = toFilterNode([{ or: [OPEN, BLOCKED] }, MINE]);
+    expect(node).toEqual([
+      ['or', ['status', 'equals', 'open'], ['status', 'equals', 'blocked']],
+      ['owner', 'equals', 'u1'],
+    ]);
+    expect(isFilterAST(node)).toBe(true);
+    expect(parseFilterAST(node as never)).toEqual({
+      $and: [{ $or: [{ status: 'open' }, { status: 'blocked' }] }, { owner: 'u1' }],
+    });
+  });
+
+  it('the HotCRM shape — open, or completed in the last 7 days — lowers each member like a top-level rule', () => {
+    const node = toFilterNode([
+      { or: [OPEN, { field: 'completed_at', operator: 'after', value: '{7_days_ago}' }] },
+    ]);
+    // `after` is canonical already, so the member is lowered verbatim beside its sibling.
+    expect(node).toEqual([['or', ['status', 'equals', 'open'], ['completed_at', 'after', '{7_days_ago}']]]);
+    expect(isFilterAST(node)).toBe(true);
+  });
+
+  it('a group of one rule lowers to that rule', () => {
+    expect(toFilterNode([{ or: [OPEN] }])).toEqual([['status', 'equals', 'open']]);
+  });
+
+  it('a member is refused for what it says, exactly as at the top level', () => {
+    const arrayOnScalar = { field: 'status', operator: 'equals', value: ['open'] };
+    expect(() => toFilterNode([arrayOnScalar])).toThrow(FilterOperatorError);
+    expect(() => toFilterNode([{ or: [OPEN, arrayOnScalar] }])).toThrow(FilterOperatorError);
+    // The render-time door answers the refusal as a value, not as no filter.
+    const safe = toFilterNodeSafely([{ or: [OPEN, arrayOnScalar] }]);
+    expect(safe.ok).toBe(false);
+  });
+
+  it('a shape the spec refuses is not repaired: it stays an object the wire door refuses', () => {
+    for (const refused of [
+      [{ or: [] }],
+      [{ or: 'status' }],
+      [{ or: [{ field: '', operator: 'equals', value: 'x' }, OPEN] }],
+      [{ or: [{ or: [OPEN] }, BLOCKED] }],
+    ]) {
+      const node = toFilterNode(refused);
+      expect(isFilterAST(node), JSON.stringify(refused)).toBe(false);
+    }
+  });
+
+  it('mergeFilterNodes keeps the lowered view filter its own child beside a user filter', () => {
+    const merged = mergeFilterNodes([{ or: [OPEN, BLOCKED] }], ['owner', '=', 'u1']);
+    expect(merged).toEqual([
+      'and',
+      [['or', ['status', 'equals', 'open'], ['status', 'equals', 'blocked']]],
+      ['owner', '=', 'u1'],
+    ]);
+    expect(isFilterAST(merged)).toBe(true);
+  });
+});
+
+describe('the lowered group selects the any-of row set (ValueDataSource, objectstack#28370)', () => {
+  it('one group: the rows matching ANY member', async () => {
+    const ids = await selectedIds([{ or: [OPEN, BLOCKED] }]);
+    expect(ids).toEqual(['a', 'b', 'e']);
+    expect(ids).not.toEqual(ALL_IDS);
+  });
+
+  it('a group ANDed with a rule: the any-of rows that also match the rule', async () => {
+    const ids = await selectedIds([{ or: [OPEN, { field: 'done_at', operator: 'greater_than', value: 5 }] }, MINE]);
+    expect(ids).toEqual(['a', 'c']);
+  });
+});
+
+describe('builderRulesOfSpecFilter — what the one-level builder can show', () => {
+  it('a list of plain rules is an AND group of them', () => {
+    expect(builderRulesOfSpecFilter([OPEN, MINE])).toEqual({ logic: 'and', rules: [OPEN, MINE] });
+    expect(builderRulesOfSpecFilter(undefined)).toEqual({ logic: 'and', rules: [] });
+  });
+
+  it('a list that is exactly one group is an OR group of its rules', () => {
+    expect(builderRulesOfSpecFilter([{ or: [OPEN, BLOCKED] }])).toEqual({ logic: 'or', rules: [OPEN, BLOCKED] });
+  });
+
+  it('a group beside anything else cannot be shown as one logic, so it is null', () => {
+    expect(builderRulesOfSpecFilter([{ or: [OPEN, BLOCKED] }, MINE])).toBeNull();
+    expect(builderRulesOfSpecFilter([{ or: [OPEN] }, { or: [BLOCKED] }])).toBeNull();
+    expect(builderRulesOfSpecFilter([{ or: 'status' }])).toBeNull();
+  });
+});
diff --git a/ui/packages/core/src/utils/filter-converter.ts b/ui/packages/core/src/utils/filter-converter.ts
index c9cb204c07f..9d945043da7 100644
--- a/ui/packages/core/src/utils/filter-converter.ts
+++ b/ui/packages/core/src/utils/filter-converter.ts
@@ -14,6 +14,7 @@
  */
 
 import {
+  isViewFilterOrGroup,
   normalizeFilterOperator,
   VIEW_FILTER_OPERATORS,
   VIEW_FILTER_LIST_VALUE_OPERATORS,
@@ -1385,13 +1386,50 @@ function viewFilterRuleToNode(rule: ViewFilterRuleLike): FilterNode {
   ) as FilterNode;
 }
 
+/**
+ * Lower ONE any-of group element of a view filter list — `{ or: [rule, ...] }`,
+ * `@objectstack/spec/ui`'s `ViewFilterOrGroupSchema` — to an `or` node of its
+ * rules, so the group sits inside the list's AND as one child.
+ *
+ * Each member is lowered by {@link viewFilterRuleToNode}, so a rule inside a
+ * group meets exactly the operator fold, arity check and comparand refusal it
+ * meets at the top level. One member is returned as its own node: an any-of over
+ * one rule selects what that rule selects.
+ *
+ * A shape the spec refuses is NOT repaired here. A group whose `or` is not a
+ * non-empty array is returned as it arrived, and so is a member that is not a
+ * rule (a blank `field`, a group inside a group): an object in AST position,
+ * which the server refuses with `400 INVALID_FILTER`. Dropping either would
+ * widen or empty the list in silence; the element kinds are told apart by the
+ * spec's own {@link isViewFilterOrGroup}, never by a second test here.
+ */
+function viewFilterOrGroupToNode(group: { or?: unknown }): unknown {
+  const members = group.or;
+  if (!Array.isArray(members) || members.length === 0) return group;
+  const nodes = members.map((member) => (isViewFilterRule(member) ? viewFilterRuleToNode(member) : member));
+  return nodes.length === 1 ? nodes[0] : ['or', ...nodes];
+}
+
+/** One element of a stored view filter list, lowered: a rule, an any-of group, or (untouched) an AST node. */
+function lowerViewFilterElement(element: unknown): unknown {
+  if (isViewFilterRule(element)) return viewFilterRuleToNode(element);
+  if (isViewFilterOrGroup(element)) return viewFilterOrGroupToNode(element);
+  return element;
+}
+
+/** Does this array carry a stored view filter element (a rule or an any-of group) to lower? */
+function carriesViewFilterElement(source: readonly unknown[]): boolean {
+  return source.some((element) => isViewFilterRule(element) || isViewFilterOrGroup(element));
+}
+
 /**
  * Normalize ONE filter source into a single filter node.
  *
  * A "source" is whatever a view hands a renderer, and there are three shapes in
  * circulation, all legitimate:
  *
- *   - `[{ field, operator, value }, ...]`  a spec `ViewFilterRule[]`
+ *   - `[{ field, operator, value }, ...]`  a spec view filter list, whose
+ *     elements may also be any-of groups `{ or: [rule, ...] }`
  *   - `[['stage', '=', 'won'], ...]`       an AST node / legacy flat array
  *   - `{ status: 'active' }`               a MongoDB-style object
  *
@@ -1429,6 +1467,12 @@ function viewFilterRuleToNode(rule: ViewFilterRuleLike): FilterNode {
  * lowering, one place; the same reason the MongoDB-style shape is lowered here
  * rather than at each of its callers.
  *
+ * An any-of group (`{ or: [rule, ...] }`, objectstack#28020) lowers to one `or`
+ * node of its rules, a child of the list's implicit AND like any rule: the list
+ * still ANDs its elements and the group ORs its members. Before this a group
+ * passed through as an object in AST position and the server refused the whole
+ * list (`400 INVALID_FILTER`).
+ *
  * Mixed arrays fold ELEMENT-WISE, because that is what reaches this function in
  * practice: `ObjectView` concatenates a saved view's rules with the
  * `?filter[<field>]=<value>` URL triples into one array. Triples pass through
@@ -1447,13 +1491,12 @@ export function toFilterNode(source: unknown): FilterNode | Record<string, any>
   if (source === null || source === undefined) return undefined;
   if (Array.isArray(source)) {
     if (source.length === 0) return undefined;
-    // Spec `ViewFilterRule[]` (possibly mixed with AST nodes) → AST nodes. Left
-    // untouched when the array holds no rule objects, which is the common case:
-    // user-filter conditions and URL triples are already nodes.
+    // A spec view filter list (possibly mixed with AST nodes) → AST nodes: a
+    // rule becomes a comparison, an any-of group `{ or: [...] }` an `or` node
+    // of its rules. Left untouched when the array holds neither, which is the
+    // common case: user-filter conditions and URL triples are already nodes.
     return (
-      source.some(isViewFilterRule)
-        ? source.map((el) => (isViewFilterRule(el) ? viewFilterRuleToNode(el) : el))
-        : source
+      carriesViewFilterElement(source) ? source.map(lowerViewFilterElement) : source
     ) as FilterNode;
   }
   if (typeof source !== 'object') return undefined;
@@ -1536,3 +1579,34 @@ export function mergeFilterNodes(
   if (nodes.length === 1) return nodes[0];
   return ['and', ...nodes] as FilterNode;
 }
+
+/** A stored view filter list as the builder's ONE logic over flat rules. */
+export interface BuilderFilterRules {
+  logic: 'and' | 'or';
+  rules: unknown[];
+}
+
+/**
+ * A stored view filter list as the filter builder's one logic over flat rules,
+ * or `null` when the builder cannot show it — the READ direction of
+ * `app-shell`'s `foldFilterGroupToSpecRules`.
+ *
+ * - A list with no any-of group is an AND group of its elements.
+ * - A list that is exactly one any-of group (`[{ or: rules }]`, what the fold
+ *   writes for an OR group, `ViewFilterOrGroupSchema`) is an OR group of its
+ *   rules.
+ * - Anything else that carries a group — a group beside other elements, two
+ *   groups, a group whose `or` is not an array — is `null`. The builder edits
+ *   one logic over flat rows, so loading such a list into it would drop the
+ *   group, or the elements beside it, on the next save, and the view would
+ *   select other records with nobody told. A caller shows it read-only.
+ *
+ * The element kinds are told apart by the spec's own `isViewFilterOrGroup`.
+ */
+export function builderRulesOfSpecFilter(stored: unknown): BuilderFilterRules | null {
+  const elements: unknown[] = Array.isArray(stored) ? stored : [];
+  if (!elements.some(isViewFilterOrGroup)) return { logic: 'and', rules: elements };
+  const only = elements.length === 1 ? elements[0] : undefined;
+  if (isViewFilterOrGroup(only) && Array.isArray(only.or)) return { logic: 'or', rules: only.or };
+  return null;
+}
diff --git a/ui/packages/data-objectstack/src/filter-or-group-28370.test.ts b/ui/packages/data-objectstack/src/filter-or-group-28370.test.ts
new file mode 100644
index 00000000000..1b71334fc11
--- /dev/null
+++ b/ui/packages/data-objectstack/src/filter-or-group-28370.test.ts
@@ -0,0 +1,113 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectstack#28370 — the adapter's own translator reads a view filter list's
+ * any-of group element, `{ or: [rule, ...] }` (`ViewFilterOrGroupSchema`).
+ *
+ * An unlowered view filter list reaches `find()` from producers that hand the
+ * stored value straight to `$filter` (a view data provider, an element data
+ * source). Before this, a list OPENING with a group was not recognised as the
+ * entry form and shipped raw (a `400 INVALID_FILTER` from the server), and a
+ * group LATER in the list had no `field`, so the adapter refused the whole
+ * query with `MalformedFilterError`. Both `find()` routes translate, so every
+ * case runs down both and asserts the same wire.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { isFilterAST, parseFilterAST } from '@objectstack/spec/data';
+import { ObjectStackAdapter, clearSharedDiscoveryCache, isMalformedFilterError } from './index';
+
+function makeAdapter() {
+  const calls: string[] = [];
+  const fetchImpl = vi.fn(async (url: any) => {
+    const u = String(url);
+    calls.push(u);
+    if (u.includes('/api/v1/discovery')) {
+      return {
+        ok: true, status: 200, statusText: 'OK',
+        json: async () => ({ success: true, data: { version: 'v1', routes: {} } }),
+      } as any;
+    }
+    return {
+      ok: true, status: 200, statusText: 'OK',
+      json: async () => ({ success: true, data: { object: 'account', records: [], total: 0 } }),
+    } as any;
+  });
+  const adapter = new ObjectStackAdapter({
+    baseUrl: 'http://localhost:3000', token: 't', autoReconnect: false, fetch: fetchImpl as any,
+  });
+  return { adapter, calls };
+}
+
+type Route = 'plain' | 'expand';
+const ROUTES: Route[] = ['plain', 'expand'];
+
+async function filterOnWire($filter: unknown, route: Route): Promise<unknown | undefined> {
+  const { adapter, calls } = makeAdapter();
+  await adapter.find('account', { $filter, ...(route === 'expand' ? { $expand: ['owner'] } : {}) } as any);
+  const dataCall = calls.filter((u) => u.includes('/data/account')).pop();
+  const raw = dataCall ? new URL(dataCall).searchParams.get('filter') : null;
+  return raw === null ? undefined : JSON.parse(raw);
+}
+
+async function findRejects($filter: unknown, route: Route) {
+  const { adapter } = makeAdapter();
+  return adapter
+    .find('account', { $filter, ...(route === 'expand' ? { $expand: ['owner'] } : {}) } as any)
+    .then(() => null, (e) => e);
+}
+
+const OPEN = { field: 'status', operator: 'equals', value: 'open' };
+const BLOCKED = { field: 'status', operator: 'equals', value: 'blocked' };
+const MINE = { field: 'owner', operator: 'equals', value: 'u1' };
+const OPEN_OR_BLOCKED = { $or: [{ status: 'open' }, { status: 'blocked' }] };
+
+describe('an any-of group in an unlowered view filter list reaches the wire as an `or` node (objectstack#28370)', () => {
+  beforeEach(() => clearSharedDiscoveryCache());
+
+  for (const route of ROUTES) {
+    it(`a list that is one group (${route} route)`, async () => {
+      const wire = await filterOnWire([{ or: [OPEN, BLOCKED] }], route);
+      expect(wire).toEqual(['or', ['status', '=', 'open'], ['status', '=', 'blocked']]);
+      expect(isFilterAST(wire)).toBe(true);
+      expect(parseFilterAST(wire as never)).toEqual(OPEN_OR_BLOCKED);
+    });
+
+    it(`a group first, then a rule (${route} route)`, async () => {
+      const wire = await filterOnWire([{ or: [OPEN, BLOCKED] }, MINE], route);
+      expect(wire).toEqual(['and', ['or', ['status', '=', 'open'], ['status', '=', 'blocked']], ['owner', '=', 'u1']]);
+      expect(parseFilterAST(wire as never)).toEqual({ $and: [OPEN_OR_BLOCKED, { owner: 'u1' }] });
+    });
+
+    it(`a rule first, then a group (${route} route)`, async () => {
+      const wire = await filterOnWire([MINE, { or: [OPEN, BLOCKED] }], route);
+      expect(wire).toEqual(['and', ['owner', '=', 'u1'], ['or', ['status', '=', 'open'], ['status', '=', 'blocked']]]);
+      expect(isFilterAST(wire)).toBe(true);
+    });
+
+    it(`a group spread into an \`and\` beside a tuple (${route} route)`, async () => {
+      const wire = await filterOnWire(['and', { or: [OPEN, BLOCKED] }, ['owner', '=', 'u1']], route);
+      expect(wire).toEqual(['and', ['or', ['status', '=', 'open'], ['status', '=', 'blocked']], ['owner', '=', 'u1']]);
+      expect(isFilterAST(wire)).toBe(true);
+    });
+
+    it(`a group that does not translate is refused whole, never dropped (${route} route)`, async () => {
+      for (const refused of [
+        [MINE, { or: [] }],
+        [MINE, { or: [OPEN, { field: '', operator: 'equals', value: 'x' }] }],
+        [{ or: [{ or: [OPEN] }] }],
+      ]) {
+        const error = await findRejects(refused, route);
+        expect(isMalformedFilterError(error), JSON.stringify(refused)).toBe(true);
+        expect((error as { code?: string }).code).toBe('INVALID_FILTER');
+        expect((error as { httpStatus?: number }).httpStatus).toBe(400);
+      }
+    });
+  }
+});
diff --git a/ui/packages/data-objectstack/src/index.ts b/ui/packages/data-objectstack/src/index.ts
index 12bac76a0f0..6f8a1e2b172 100644
--- a/ui/packages/data-objectstack/src/index.ts
+++ b/ui/packages/data-objectstack/src/index.ts
@@ -13,6 +13,9 @@ import type { ListViewGroupHeaderRow } from '@objectstack/spec/ui';
 // ViewItem record are the spec's own record of the console's round-trip keys,
 // read off the pin rather than hand-listed (see `VIEW_ITEM_ROUND_TRIP_KEYS`).
 import { VIEW_CONSOLE_ROUND_TRIP_KEYS } from '@objectstack/spec/ui';
+// The spec's one test for a view filter list's any-of group element
+// (`{ or: [rule, ...] }`), read here rather than restated.
+import { isViewFilterOrGroup } from '@objectstack/spec/ui';
 // #4934 — a VALUE import, not a type one: the write-warning boundary parses the
 // wire's `reason` against the enum the spec itself declares, so the accept set
 // is read off the pin instead of hand-copied here (a hand copy is the drift
@@ -656,13 +659,38 @@ function isObjectFilterEntryForm(filter: readonly unknown[]): boolean {
     && typeof first === 'object'
     && first !== null
     && !Array.isArray(first)
-    && (first as any).field !== undefined;
+    // A view filter list may open with an any-of group (`{ or: [...] }`), which
+    // carries no `field` of its own.
+    && ((first as any).field !== undefined || isViewFilterOrGroup(first));
+}
+
+/**
+ * One any-of group element of a view filter list — `{ or: [rule, ...] }`,
+ * `@objectstack/spec/ui`'s `ViewFilterOrGroupSchema` — to an `or` node of its
+ * rules' tuples (one member: that member's tuple), or `null` when it is not a
+ * usable group: an `or` that is not a non-empty array, or a member that is not
+ * a usable rule. Every member is translated by {@link objectFilterEntryToAST},
+ * so a rule inside a group is refused for what it says exactly as at the top
+ * level. `index` is the group's position in its list.
+ */
+function objectFilterOrGroupToAST(group: { or?: unknown }, index: number): unknown[] | null {
+  const members = group.or;
+  if (!Array.isArray(members) || members.length === 0) return null;
+  const tuples: unknown[] = [];
+  for (const member of members) {
+    const tuple = objectFilterEntryToAST(member, index);
+    if (!tuple) return null;
+    tuples.push(tuple);
+  }
+  return tuples.length === 1 ? (tuples[0] as unknown[]) : ['or', ...tuples];
 }
 
 /**
  * Translate `[{ field, operator, value }, ...]` into a filter AST node. Every
  * entry must translate; see `MalformedFilterError` for why one that doesn't is
- * an error rather than an omission.
+ * an error rather than an omission. An any-of group entry translates to one
+ * `or` node inside the list's `and`, and a group that does not translate is
+ * refused whole, by the same error.
  */
 function objectFilterEntriesToAST(entries: readonly unknown[]): unknown[] {
   const nodes = entries.map((entry, i) => {
@@ -670,6 +698,11 @@ function objectFilterEntriesToAST(entries: readonly unknown[]): unknown[] {
     // both conditions instead of losing one to a drop or the whole query to an
     // error.
     if (Array.isArray(entry)) return translateFilterChild(entry, i);
+    if (isViewFilterOrGroup(entry)) {
+      const node = objectFilterOrGroupToAST(entry, i);
+      if (!node) throw new MalformedFilterError(entry, i);
+      return node;
+    }
     const tuple = objectFilterEntryToAST(entry, i);
     if (!tuple) throw new MalformedFilterError(entry, i);
     return tuple;
@@ -743,6 +776,9 @@ function translateFilterArray(filter: unknown[]): unknown[] {
  */
 function translateFilterChild(child: unknown, index: number): unknown {
   if (Array.isArray(child)) return child.length > 0 ? translateFilterArray(child) : child;
+  // A spread any-of group element: translated when every member is a usable
+  // rule, otherwise left for the server to refuse, like a bare rule above.
+  if (isViewFilterOrGroup(child)) return objectFilterOrGroupToAST(child, index) ?? child;
   if (child && typeof child === 'object' && (child as any).field !== undefined) {
     const tuple = objectFilterEntryToAST(child, index);
     if (tuple) return tuple;
@@ -755,7 +791,8 @@ function translateFilterChild(child: unknown, index: number): unknown {
  * understood by the ObjectStack server's `parseFilterAST()`.
  *
  * Accepted inputs:
- *   - `[{ field, operator, value }, ...]` — ViewFilterRule[] from view configs
+ *   - `[{ field, operator, value }, ...]` — a view filter list from view configs,
+ *     whose elements may also be any-of groups `{ or: [rule, ...] }`
  *   - `[field, op, value]`                — single AST tuple (passed through)
  *   - `['and'|'or', ...children]`         — logical AST node (passed through)
  *   - `[[...], [...]]`                    — legacy nested AST (passed through)
diff --git a/ui/packages/i18n/src/locales/ar.ts b/ui/packages/i18n/src/locales/ar.ts
index 5cda3ff0950..73b1a286a57 100644
--- a/ui/packages/i18n/src/locales/ar.ts
+++ b/ui/packages/i18n/src/locales/ar.ts
@@ -2506,7 +2506,7 @@ const ar = {
       objectNotFoundDescription: "الكائن \"{{objectName}}\" غير موجود في الإعدادات الحالية.",
       objectNotFoundHint: "تحقق من إعدادات التنقل في تطبيقك أو اختر كائنًا آخر من الشريط الجانبي.",
       objectPackageDisabled: "الكائن \"{{objectName}}\" ينتمي إلى حزمة معطّلة، لذلك لا يتم تقديمه.",
-      filterOrNotSavable: "يستخدم هذا الفلتر «أو» بين الشروط، وهو ما لا يمكن للعرض المحفوظ تخزينه بعد. لا يزال مطبقًا على هذه القائمة — أزل تجميع «أو» لحفظه في العرض.",
+      filterOrGroupNotEditable: "يحتوي هذا الفلتر على مجموعة «أو» إلى جانب شروط أخرى، ولا يستطيع محرر الفلاتر عرضها، لذا فهو للقراءة فقط هنا. لا يزال العرض يطبّقه.",
       filterNestedNotSavable: "يستخدم هذا الفلتر مجموعات شروط متداخلة لا يمكن للعرض المحفوظ تخزينها. حوّله إلى قائمة شروط واحدة لحفظه في العرض.",
       allRecords: "جميع السجلات",
       new: "جديد",
diff --git a/ui/packages/i18n/src/locales/de.ts b/ui/packages/i18n/src/locales/de.ts
index fceef129692..9e5dec11e3e 100644
--- a/ui/packages/i18n/src/locales/de.ts
+++ b/ui/packages/i18n/src/locales/de.ts
@@ -2279,7 +2279,7 @@ const de = {
       objectNotFoundDescription: "Das Objekt „{{objectName}}“ existiert in der aktuellen Konfiguration nicht.",
       objectNotFoundHint: "Überprüfen Sie Ihre App-Navigationseinstellungen oder wählen Sie ein anderes Objekt aus der Seitenleiste.",
       objectPackageDisabled: "Das Objekt „{{objectName}}“ gehört zu einem deaktivierten Paket und wird daher nicht bereitgestellt.",
-      filterOrNotSavable: "Dieser Filter verknüpft Bedingungen mit ODER, was eine gespeicherte Ansicht noch nicht ablegen kann. Er gilt weiterhin für diese Liste – entfernen Sie die ODER-Gruppierung, um ihn in der Ansicht zu speichern.",
+      filterOrGroupNotEditable: "Dieser Filter enthält neben anderen Bedingungen eine ODER-Gruppe, die der Filter-Editor nicht darstellen kann, daher ist er hier schreibgeschützt. Die Ansicht wendet ihn weiterhin an.",
       filterNestedNotSavable: "Dieser Filter verwendet verschachtelte Bedingungsgruppen, die eine gespeicherte Ansicht nicht ablegen kann. Reduzieren Sie ihn auf eine einzelne Bedingungsliste, um ihn in der Ansicht zu speichern.",
       allRecords: "Alle Datensätze",
       new: "Neu",
diff --git a/ui/packages/i18n/src/locales/en.ts b/ui/packages/i18n/src/locales/en.ts
index 644ede2e990..b4ff5a0cd84 100644
--- a/ui/packages/i18n/src/locales/en.ts
+++ b/ui/packages/i18n/src/locales/en.ts
@@ -2800,7 +2800,7 @@ const en = {
       objectNotFoundDescription: 'The object "{{objectName}}" does not exist in the current configuration.',
       objectNotFoundHint: 'Check your app navigation settings or select a different object from the sidebar.',
       objectPackageDisabled: 'The object "{{objectName}}" belongs to a package that is disabled, so it is not being served.',
-      filterOrNotSavable: 'This filter uses OR between conditions, which a saved view cannot store yet. It still applies to this list — remove the OR grouping to save it to the view.',
+      filterOrGroupNotEditable: 'This filter has an OR group beside other conditions, which the filter editor cannot show, so it is read-only here. The view still applies it.',
       filterNestedNotSavable: 'This filter uses nested condition groups, which a saved view cannot store. Flatten it to a single list of conditions to save it to the view.',
       systemViewReadonly: 'System view defined in code — read-only.',
       // ObjectView.tsx references ONE edit-denied key from four call sites
diff --git a/ui/packages/i18n/src/locales/es.ts b/ui/packages/i18n/src/locales/es.ts
index 203711f8a25..bfa71f592c1 100644
--- a/ui/packages/i18n/src/locales/es.ts
+++ b/ui/packages/i18n/src/locales/es.ts
@@ -2338,7 +2338,7 @@ const es = {
       objectNotFoundDescription: "El objeto \"{{objectName}}\" no existe en la configuración actual.",
       objectNotFoundHint: "Verifique la configuración de navegación de su aplicación o seleccione un objeto diferente en la barra lateral.",
       objectPackageDisabled: "El objeto \"{{objectName}}\" pertenece a un paquete deshabilitado, por lo que no se está sirviendo.",
-      filterOrNotSavable: "Este filtro une las condiciones con O, algo que una vista guardada aún no puede almacenar. Se sigue aplicando a esta lista: quite la agrupación O para guardarlo en la vista.",
+      filterOrGroupNotEditable: "Este filtro tiene un grupo O junto a otras condiciones, que el editor de filtros no puede mostrar, así que aquí es de solo lectura. La vista lo sigue aplicando.",
       filterNestedNotSavable: "Este filtro usa grupos de condiciones anidados, que una vista guardada no puede almacenar. Conviértalo en una única lista de condiciones para guardarlo en la vista.",
       allRecords: "Todos los registros",
       new: "Nuevo",
diff --git a/ui/packages/i18n/src/locales/fr.ts b/ui/packages/i18n/src/locales/fr.ts
index d9e79db72c9..1b1cd1f5d18 100644
--- a/ui/packages/i18n/src/locales/fr.ts
+++ b/ui/packages/i18n/src/locales/fr.ts
@@ -2334,7 +2334,7 @@ const fr = {
       objectNotFoundDescription: "L'objet « {{objectName}} » n'existe pas dans la configuration actuelle.",
       objectNotFoundHint: "Vérifiez les paramètres de navigation de votre application ou sélectionnez un autre objet dans la barre latérale.",
       objectPackageDisabled: "L'objet « {{objectName}} » appartient à un package désactivé et n'est donc pas servi.",
-      filterOrNotSavable: "Ce filtre relie les conditions par OU, ce qu'une vue enregistrée ne peut pas encore stocker. Il s'applique toujours à cette liste — supprimez le groupement OU pour l'enregistrer dans la vue.",
+      filterOrGroupNotEditable: "Ce filtre comporte un groupe OU à côté d'autres conditions, que l'éditeur de filtres ne peut pas afficher, il est donc en lecture seule ici. La vue l'applique toujours.",
       filterNestedNotSavable: "Ce filtre utilise des groupes de conditions imbriqués, qu'une vue enregistrée ne peut pas stocker. Aplatissez-le en une seule liste de conditions pour l'enregistrer dans la vue.",
       allRecords: "Tous les enregistrements",
       new: "Nouveau",
diff --git a/ui/packages/i18n/src/locales/ja.ts b/ui/packages/i18n/src/locales/ja.ts
index 062ab9cf899..e0944df3f6d 100644
--- a/ui/packages/i18n/src/locales/ja.ts
+++ b/ui/packages/i18n/src/locales/ja.ts
@@ -2281,7 +2281,7 @@ const ja = {
       objectNotFoundDescription: "オブジェクト「{{objectName}}」は現在の設定に存在しません。",
       objectNotFoundHint: "アプリのナビゲーション設定を確認するか、サイドバーから別のオブジェクトを選択してください。",
       objectPackageDisabled: "オブジェクト「{{objectName}}」が属するパッケージは無効になっているため、提供されていません。",
-      filterOrNotSavable: "このフィルターは条件間に OR を使用しており、保存済みビューにはまだ保存できません。現在のリストには適用されています。ビューに保存するには OR グループを解除してください。",
+      filterOrGroupNotEditable: "このフィルターには他の条件と並んで OR グループが含まれており、フィルターエディターでは表示できないため、ここでは読み取り専用です。ビューには引き続き適用されます。",
       filterNestedNotSavable: "このフィルターはネストされた条件グループを使用しており、保存済みビューには保存できません。ビューに保存するには単一の条件リストに展開してください。",
       allRecords: "すべてのレコード",
       new: "新規",
diff --git a/ui/packages/i18n/src/locales/ko.ts b/ui/packages/i18n/src/locales/ko.ts
index 9e2026b0e5f..934e9a1461e 100644
--- a/ui/packages/i18n/src/locales/ko.ts
+++ b/ui/packages/i18n/src/locales/ko.ts
@@ -2279,7 +2279,7 @@ const ko = {
       objectNotFoundDescription: "객체 \"{{objectName}}\"이(가) 현재 구성에 존재하지 않습니다.",
       objectNotFoundHint: "앱 탐색 설정을 확인하거나 사이드바에서 다른 객체를 선택하세요.",
       objectPackageDisabled: "객체 \"{{objectName}}\"이(가) 속한 패키지가 비활성화되어 있어 제공되지 않습니다.",
-      filterOrNotSavable: "이 필터는 조건 사이에 OR을 사용하며, 저장된 뷰에는 아직 저장할 수 없습니다. 현재 목록에는 계속 적용됩니다. 뷰에 저장하려면 OR 그룹을 해제하세요.",
+      filterOrGroupNotEditable: "이 필터에는 다른 조건과 함께 OR 그룹이 있어 필터 편집기에서 표시할 수 없으므로 여기서는 읽기 전용입니다. 뷰에는 계속 적용됩니다.",
       filterNestedNotSavable: "이 필터는 중첩된 조건 그룹을 사용하며, 저장된 뷰에는 저장할 수 없습니다. 뷰에 저장하려면 단일 조건 목록으로 펼치세요.",
       allRecords: "모든 레코드",
       new: "새로 만들기",
diff --git a/ui/packages/i18n/src/locales/pt.ts b/ui/packages/i18n/src/locales/pt.ts
index 7fe40bfb534..cfeeea0d546 100644
--- a/ui/packages/i18n/src/locales/pt.ts
+++ b/ui/packages/i18n/src/locales/pt.ts
@@ -2333,7 +2333,7 @@ const pt = {
       objectNotFoundDescription: "O objeto \"{{objectName}}\" não existe na configuração atual.",
       objectNotFoundHint: "Verifique as configurações de navegação do seu aplicativo ou selecione um objeto diferente na barra lateral.",
       objectPackageDisabled: "O objeto \"{{objectName}}\" pertence a um pacote desativado e, por isso, não está sendo servido.",
-      filterOrNotSavable: "Este filtro une as condições com OU, algo que uma visão salva ainda não consegue armazenar. Ele continua aplicado a esta lista — remova o agrupamento OU para salvá-lo na visão.",
+      filterOrGroupNotEditable: "Este filtro tem um grupo OU ao lado de outras condições, que o editor de filtros não consegue exibir, por isso aqui é somente leitura. A visão continua aplicando o filtro.",
       filterNestedNotSavable: "Este filtro usa grupos de condições aninhados, que uma visão salva não consegue armazenar. Transforme-o em uma única lista de condições para salvá-lo na visão.",
       allRecords: "Todos os registros",
       new: "Novo",
diff --git a/ui/packages/i18n/src/locales/ru.ts b/ui/packages/i18n/src/locales/ru.ts
index 8c8d3164ab1..3b45b4385ab 100644
--- a/ui/packages/i18n/src/locales/ru.ts
+++ b/ui/packages/i18n/src/locales/ru.ts
@@ -2399,7 +2399,7 @@ const ru = {
       objectNotFoundDescription: "Объект «{{objectName}}» не существует в текущей конфигурации.",
       objectNotFoundHint: "Проверьте настройки навигации приложения или выберите другой объект на боковой панели.",
       objectPackageDisabled: "Объект «{{objectName}}» принадлежит отключённому пакету, поэтому он не предоставляется.",
-      filterOrNotSavable: "Этот фильтр объединяет условия через ИЛИ, что сохранённое представление пока не может хранить. Он по-прежнему применяется к этому списку — уберите группировку ИЛИ, чтобы сохранить его в представлении.",
+      filterOrGroupNotEditable: "В этом фильтре рядом с другими условиями есть группа ИЛИ, которую редактор фильтров не может показать, поэтому здесь он доступен только для чтения. Представление по-прежнему его применяет.",
       filterNestedNotSavable: "Этот фильтр использует вложенные группы условий, которые сохранённое представление не может хранить. Преобразуйте его в один список условий, чтобы сохранить в представлении.",
       allRecords: "Все записи",
       new: "Создать",
diff --git a/ui/packages/i18n/src/locales/zh.ts b/ui/packages/i18n/src/locales/zh.ts
index ec94d36721e..a5980163a86 100644
--- a/ui/packages/i18n/src/locales/zh.ts
+++ b/ui/packages/i18n/src/locales/zh.ts
@@ -2364,7 +2364,7 @@ const zh = {
       objectNotFoundDescription: '对象"{{objectName}}"在当前配置中不存在。',
       objectNotFoundHint: '请检查您的应用导航设置或从侧边栏选择其他对象。',
       objectPackageDisabled: '对象“{{objectName}}”所属的软件包已被禁用，因此当前不提供该对象。',
-      filterOrNotSavable: '该筛选条件之间使用「或」,保存到视图暂不支持这种结构。它仍会作用于当前列表 —— 取消「或」分组后才能保存到视图。',
+      filterOrGroupNotEditable: '该筛选条件在其他条件之外还含有一个「或」分组，筛选编辑器无法显示这种结构，因此此处只读。视图仍会应用它。',
       filterNestedNotSavable: '该筛选使用了嵌套条件分组,保存到视图不支持这种结构。请改为单层条件列表后再保存到视图。',
       allRecords: '所有记录',
       new: '新建',
diff --git a/ui/packages/plugin-view/src/config/view-config-utils.ts b/ui/packages/plugin-view/src/config/view-config-utils.ts
index ec900a8a9dd..560c363f804 100644
--- a/ui/packages/plugin-view/src/config/view-config-utils.ts
+++ b/ui/packages/plugin-view/src/config/view-config-utils.ts
@@ -10,7 +10,7 @@ import type { FilterBuilderOperator, FilterBuilderRowGroup, SortItem } from '@ob
 // `@object-ui/fields` dependency — and does not gain one here — so it reads
 // the gate from its home in `@object-ui/core`, which `fields` re-exports
 // verbatim. One table, one dedupe set, no new package edge.
-import { isRetiredFieldType, reportRetiredFieldType } from '@object-ui/core';
+import { builderRulesOfSpecFilter, isRetiredFieldType, reportRetiredFieldType } from '@object-ui/core';
 import { VIEW_FILTER_OPERATORS, VIEW_FILTER_OPERATOR_ALIASES } from '@objectstack/spec/ui';
 import type { ViewFilterOperator } from '@objectstack/spec/ui';
 
@@ -165,11 +165,26 @@ function parseSingleOrNested(item: any): Array<{ id: string; field: string; oper
     return [];
 }
 
+/**
+ * A stored filter as a builder group.
+ *
+ * A spec view filter list that is one any-of group (`[{ or: rules }]`) reads
+ * back as an OR group of its rules, so an OR group the builder saved returns
+ * as the OR group it was ({@link builderRulesOfSpecFilter}). A list the builder
+ * cannot show — a group beside other elements — reads as its flat rules only;
+ * a caller that would SAVE what the builder holds asks
+ * {@link builderRulesOfSpecFilter} first and does not offer it for editing.
+ */
 export function parseSpecFilter(raw: any): { logic: 'and' | 'or'; conditions: Array<{ id: string; field: string; operator: string; value: any }> } {
     if (!Array.isArray(raw) || raw.length === 0) {
         return { logic: 'and', conditions: [] };
     }
 
+    const asOrGroup = builderRulesOfSpecFilter(raw);
+    if (asOrGroup?.logic === 'or') {
+        return { logic: 'or', conditions: asOrGroup.rules.flatMap((item: any) => parseSingleOrNested(item)) };
+    }
+
     // Detect ['and', ...conditions] or ['or', ...conditions]
     if (typeof raw[0] === 'string' && (raw[0] === 'and' || raw[0] === 'or')) {
         const logic = raw[0] as 'and' | 'or';