@@ -617,7 +617,7 @@ Sort field and direction pair
 | **groupBy** | `string` | optional | Field whose values become the board columns |
 | **columns** | `any[]` | optional | Swimlane definitions (`{ id, title }` per `groupBy` value, or bare value strings) — NOT a field projection |
 | **filter** | `{ field: string; operator: Enum<'equals' \| 'not_equals' \| 'contains' \| 'not_contains' \| 'icontains' \| …>; value?: string \| number \| boolean \| null \| (string \| number)[] }[]` | optional | Base query filter, handed to the wire `$filter` — the ViewFilterRule array form `[{ field, operator, value }, ...]`, the one filter orthography every `filter` door in this map shares. The MongoDB-style record form is refused — see migration `element-data-source-and-object-block-filter-rule-array` |
-| **limit** | `integer` | optional | Maximum number of records loaded onto the board (row cap); lowered to the query's top-level `$top` (renderer default 100). The component-level `dataSource.limit` wins when both are set; a bound view's row cap (`pagination.pageSize`, else that view's flat `limit`) fills this key unless it already carries a USABLE cap — a cap the contract refuses (zero, negative, fractional) is displaced by the view's and reported, not honoured |
+| **limit** | `integer` | optional | Maximum number of records loaded onto the board (row cap); lowered to the query's top-level `$top` (renderer default 100). The component-level `dataSource.limit` wins when both are set; a bound view's `pagination.pageSize` fills this key only when it is unset — and on this face unset is the whole rule, because every cap this key accepts is one the binding gate already treats as authored |
 | **data** | `any[]` | optional | Static inline cards — bypasses the object query |
 | **cardTitle** | `string` | optional | Field rendered as each card title |
 | **titleField** | `string` | optional | Legacy fallback for `cardTitle` (the board reads `cardTitle \|\| titleField`). Prefer `cardTitle` |
 
@@ -3857,17 +3857,37 @@ describe('row caps on the object-bound blocks — what #19228 recorded', () => {
     expect(JSON.stringify(control.error?.issues)).toContain('unrecognized_keys');
   });
 
-  it('states the gate guard the gate actually implements, not the narrower 「unset」 arm', () => {
-    // ⛔ The one prose assertion here, and it is negative on purpose: this
-    // card's whole repair IS the published sentence, so without a pin the
-    // change has no falsifier. The retired wording claimed the view's cap
-    // lands ONLY on an unset key; measured, it also lands on a key set to a
-    // cap the contract refuses, with `describeDisplacedRowLimit` reporting it.
-    const shape = (ObjectKanbanPropsSchema as unknown as {
-      def: { shape: Record<string, { description?: string }> };
-    }).def.shape;
-    const description = shape.limit?.description ?? '';
-    expect(description).not.toContain('only when unset');
-    expect(description).toMatch(/usable cap/i);
+  it('admits exactly the caps the binding gate calls usable — which is WHY 「unset」 is the whole rule', () => {
+    // ⛔ Not a prose pin. The published sentence says a bound view's
+    // `pagination.pageSize` fills this key only when it is UNSET, and this is
+    // the structural fact that makes that true rather than narrow:
+    // `ElementDataSourceGate`'s guard is `!isUsableRowLimit(authored)` with
+    // `isUsableRowLimit = typeof v === 'number' && Number.isInteger(v) && v > 0`
+    // — the same set this key declares. So across the whole accept set the
+    // guard has exactly two outcomes, and 「set but not usable」 is empty.
+    // If either side ever widens (a `.nullable()`, a `0` sentinel, a float),
+    // this reds and the sentence has to be rewritten with it.
+    const usableToTheGate = (v: unknown): boolean =>
+      typeof v === 'number' && Number.isInteger(v) && v > 0;
+
+    // ACCEPTED by the schema ⇒ usable to the gate ⇒ the view's cap does NOT land.
+    for (const cap of [1, 25, 100, 5000]) {
+      const r = kanban.safeParse({ objectName: 'x', limit: cap });
+      expect(r.success, `accept ${cap}`).toBe(true);
+      expect(usableToTheGate((r.success ? r.data : {} as never).limit), `usable ${cap}`).toBe(true);
+    }
+
+    // REFUSED by the schema ⇒ never reaches the gate from a valid document,
+    // which is why the displaced-and-reported arm is not in the describe.
+    for (const cap of [0, -1, 2.5, '100', null]) {
+      expect(kanban.safeParse({ objectName: 'x', limit: cap }).success, `refuse ${JSON.stringify(cap)}`).toBe(false);
+      expect(usableToTheGate(cap), `gate also rejects ${JSON.stringify(cap)}`).toBe(false);
+    }
+
+    // UNSET — accepted, and the one state the gate treats as unauthored.
+    const unset = kanban.safeParse({ objectName: 'x' });
+    expect(unset.success).toBe(true);
+    expect(Object.prototype.hasOwnProperty.call(unset.success ? unset.data : {}, 'limit')).toBe(false);
+    expect(usableToTheGate(undefined)).toBe(false);
   });
 });
@@ -3092,24 +3092,39 @@ export const ObjectKanbanPropsSchema = lazySchema(() => strictObject({
    * Why the carrier is `limit` and not the bound view's `pagination.pageSize`
    * (the alternative the card opened): precedence is the `ElementDataSourceGate`
    * table, not this key's. The component-level `dataSource.limit` overrides
-   * this key unconditionally; a bound named view's row cap is LOWERED INTO it
-   * through the `limit: 'limit'` mapping only when this key does not already
-   * carry a USABLE cap (`react/src/element-data-source/ElementDataSourceGate.tsx:316-331`,
+   * this key unconditionally; a bound named view's `pagination.pageSize` is
+   * LOWERED INTO it through the `limit: 'limit'` mapping only when this key is
+   * unset (`react/src/element-data-source/ElementDataSourceGate.tsx:316-331`,
    * `readLimit`/`writeLimit` keyed by `ElementDataSourceLimitKey`; the branch
    * gained objectui#9899's presence-is-not-authorship test and a
    * `describeDisplacedRowLimit` report on this hop).
    *
-   * ⚠️ 「only when UNSET」 is what this docblock and the describe beside it
-   * used to say, and it is narrower than the guard — re-READ first-hand at the
-   * pin `87af769e9` on 2026-09-21T06:35Z. The branch is
-   * `if (!fromView || !isUsableRowLimit(authored))`, so the view's cap also
-   * lands when this key IS set to a value the contract refuses (`0`, negative,
-   * fractional, non-number), with `describeDisplacedRowLimit` telling the
-   * author. Unset is one arm of that guard, not the whole of it. The view half
-   * is likewise not `pagination.pageSize` alone: `savedViewLimit` reads
-   * `pagination.pageSize`, else that view's FLAT `limit`
-   * (`core/src/data-scope/element-data-source.ts:237-241`); the per-kind
-   * `kanban.limit` #19226 declared takes neither of those two doors.
+   * ⚠️ 「only when UNSET」 reads narrower than the guard and is nonetheless
+   * EXACTLY right on this face — a correction to a correction, measured
+   * 2026-09-21T10:20Z. The branch is
+   * `if (!fromView || !isUsableRowLimit(authored))`, and
+   * `isUsableRowLimit` is `typeof v === 'number' && Number.isInteger(v) && v > 0`
+   * (`ElementDataSourceGate.tsx:192-194`) — the SAME set this key declares,
+   * `z.number().int().positive()`. So for every node this schema ACCEPTS,
+   * `authored` is either absent (not usable ⇒ the view's cap lands) or a
+   * positive integer (usable ⇒ it does not): unset is the only reachable arm.
+   * The extra arm — a cap displaced and reported because it is `0`, negative
+   * or fractional — is reachable ONLY for a node this contract refuses, so
+   * ⛔ it does not belong in an author-facing describe. Pinned structurally
+   * beside the parse pins in `component.test.ts` rather than as prose.
+   *
+   * ⚠️ And the view half is `pagination.pageSize` ALONE on this face.
+   * `savedViewLimit` does fall back to a flat `view.limit`
+   * (`core/src/data-scope/element-data-source.ts:237-241`), but that names a
+   * THIRD face — a saved-view RECORD as the adapter's `listViews()` returns it
+   * — not an authored view document. Measured on this tree: `ListViewSchema`
+   * REFUSES a flat `limit` with `unrecognized_keys: ["limit"]`, the same
+   * verdict a bogus key gets, while the same minimal document parses with
+   * `pagination.pageSize: 50` and with a per-kind `kanban.limit: 50`. There is
+   * no flat `limit` member on any view document and no `retiredKey()`
+   * tombstone for one. ⛔ So naming that arm here would put a runtime-record
+   * shape on the author face with no qualifier — the face-merge this card has
+   * now failed on three times.
    * ⛔ This note reports the guard; it picks no precedence.
    *
    * ⚠️ It takes a THIRD door, and missing it is what the at-tier review of
@@ -3146,7 +3161,7 @@ export const ObjectKanbanPropsSchema = lazySchema(() => strictObject({
    * a schema default would materialize `limit: 100` on every parsed board.
    */
   limit: z.number().int().positive().optional()
-    .describe("Maximum number of records loaded onto the board (row cap); lowered to the query's top-level `$top` (renderer default 100). The component-level `dataSource.limit` wins when both are set; a bound view's row cap (`pagination.pageSize`, else that view's flat `limit`) fills this key unless it already carries a USABLE cap — a cap the contract refuses (zero, negative, fractional) is displaced by the view's and reported, not honoured"),
+    .describe("Maximum number of records loaded onto the board (row cap); lowered to the query's top-level `$top` (renderer default 100). The component-level `dataSource.limit` wins when both are set; a bound view's `pagination.pageSize` fills this key only when it is unset — and on this face unset is the whole rule, because every cap this key accepts is one the binding gate already treats as authored"),
   data: z.array(z.unknown()).optional().describe('Static inline cards — bypasses the object query'),
   cardTitle: z.string().optional().describe('Field rendered as each card title'),
   titleField: z.string().optional().describe('Legacy fallback for `cardTitle` (the board reads `cardTitle || titleField`). Prefer `cardTitle`'),
 
@@ -1234,10 +1234,24 @@ type RowLimitView = keyof typeof ROW_LIMIT_SUBJECT;
  * `87af769e9`), 2026-09-21T09:15Z, with TWO instruments, because one was not
  * enough and the first one's answer was wrong:
  *
- *  1. PROPERTY-ACCESS spellings — `.kanban.limit` / `.gallery.limit` /
- *     `.timeline.limit` and the receiver alternation: **0** hits. Lit control,
- *     identical shape, `.kanban.groupByField` / `.gallery.coverField` /
- *     `.timeline.scale`: **13** lines. A live instrument, and a WRONG answer.
+ *  1. PROPERTY-ACCESS spellings. ⛔ Published as its EXPRESSION, not as a
+ *     number — this card exists because a confident count was wrong once, so
+ *     a control nobody can re-derive is not a control. Run at the pin, from
+ *     an objectui checkout, over every tracked file:
+ *       probe:   git grep -nIE '\.(kanban|gallery|timeline)(\?)?\.limit\b'
+ *       control: git grep -nIE '\.(kanban|gallery|timeline)(\?)?\.(groupByField|scale|coverField)\b'
+ *     Probe: **0** lines, 0 files. Control: **13** lines across **6** files —
+ *     `app-shell/src/views/ObjectView.galleryBinding-7547.test.tsx:41`,
+ *     `app-shell/src/views/ObjectView.tsx:450`,
+ *     `plugin-list/src/ListView.tsx:2538`, `:2540`, `:2547`, `:3057`, `:3114`,
+ *     `:3116`,
+ *     `plugin-list/src/__tests__/ListView.kanbanOptionsBagCanonical-8193.test.tsx:42`,
+ *     `:99`, `plugin-view/src/ObjectView.tsx:1695`, and
+ *     `types/src/__tests__/object-kanban-group-by-limit-7322.test.ts:146`, `:148`.
+ *     ⚠️ Filtering changes that number and the filter must be stated with it:
+ *     3 of the 13 are in COMMENTS and 2 more sit inside a quoted source-text
+ *     pin, so a reader counting executable reads only gets **8**. All three
+ *     readings are of one hit set. A live instrument — and a WRONG answer.
  *  2. ⭐ SPREADS — a spread carries a key without ever spelling it, so it is
  *     the hole instrument 1 cannot see by construction. ⛔ Re-take it by its
  *     PREDICATE, not by its count: **a spread whose target is the object
@@ -1246,6 +1260,13 @@ type RowLimitView = keyof typeof ROW_LIMIT_SUBJECT;
  *     the lit control for the instrument AND the example of what the predicate
  *     excludes). A grep broad enough to find these also returns the nested
  *     merges, so the rule, not the number, is what makes it reproducible.
+ *     ⛔ And name what the predicate EXCLUDES, or the next reader re-finds
+ *     it and wonders: `app-shell/src/views/ObjectView.tsx:206` and `:342`
+ *     ARE spreads of a view block, inside `timelineViewOptions` (`:201`) and
+ *     `galleryViewOptions` (`:334`). They build an OPTIONS BAG that feeds
+ *     `ListView`'s nested forward, not the object literal an adapter returns
+ *     as the node, so the predicate excludes them — deliberately, not by
+ *     oversight.
  *     Under that predicate, at that pin, the VIEW-face per-kind blocks give:
  *       `plugin-list/src/ListView.tsx:2979`   `...restKanban`
  *       `plugin-view/src/ObjectView.tsx:1638`  `...restKanban`