@@ -21,11 +21,17 @@ objectui#7322 justified it as "every documented and tested `object-kanban` node
 this key", and objectui#7780 recorded two producers excluded from that count; both are
 still live:
 
-- `content/docs/utilities/data-objectstack.mdx` documents an `object-kanban` node that
-  is exactly `{ type, dataSource }`, with no `groupBy`;
 - `packages/plugin-list/src/ListView.tsx` **generates** the node as
-  `groupBy: laneField`, where `laneField` ends in an explicit `|| undefined`, so a view
-  that declares no lane field emits `groupBy: undefined` at runtime.
+  `groupBy: laneField`. `objectDef` loads asynchronously, so `laneField` is `undefined`
+  on every load until it lands, and stays `undefined` whenever the object offers no
+  `stageField` hint and none of `status` / `stage` / `state` / `phase`. The renderer
+  serves that node; both published faces refused it.
+- `content/docs/utilities/data-objectstack.mdx` documents an `object-kanban` node that
+  is exactly `{ type, dataSource }`, with no `groupBy`. ⚠️ This one is weaker and is
+  cited for what it is: that fragment is **still** refused after this change, at
+  `RECORD_SOURCE_REQUIRED`, because `dataSource` is not a rung of the record-source
+  ladder. It shows a lane-less board is a documented authoring; it is not a document
+  this change admits.
 
 **What a lane-less board does, measured rather than assumed.** Every `schema.groupBy`
 read in `ObjectKanban.tsx` is a guarded early-return, so the board degrades instead of
 
@@ -932,7 +932,7 @@ A drag-and-drop Kanban board. The `object-kanban` type key validates the shape t
 | Property | Type | Description |
 |----------|------|-------------|
 | `objectName` | `string` | Object to fetch records from. |
-| `groupBy` | `string` | **Required.** Field whose values become the lanes (maps to column ids). |
+| `groupBy` | `string` | Field whose values become the lanes (maps to column ids). **Optional** since objectui#8990, matching `@objectstack/spec`. A board that omits it draws whatever lanes `columns` declares — and holds **no cards**, because records are only distributed once a lane key exists. |
 | `columns` | `string[] \| KanbanLane[]` | Swimlane definitions — an array of `{ id, title }` lanes (one per `groupBy` value), **or** an array of bare value strings; never a mix. **Not** a field projection (that is `cardFields`). A lane's `cards` is optional: an object-bound board buckets records into the lane by `groupBy`, and only a static board writes a lane's cards itself. |
 | `titleField` | `string` | Field used as the card title. |
 | `cardFields` | `string[]` | Fields rendered on each card. |
@@ -947,11 +947,11 @@ A drag-and-drop Kanban board. The `object-kanban` type key validates the shape t
 
 > `columns` is declared on this face since objectui#8913, as the pair of array shapes `@objectstack/spec` declares — an array of `{ id, title }` lanes, **or** an array of bare value strings. A **mixed** array is refused: the renderer decides which shape it has from the first element alone, so a mix yields a blank lane and mis-bucketed cards. A lane accepts `id`, `title`, `cards`, `limit`, `className` and `collapsed`, which are the members the board implementations read; `id` is a **string** — a non-string lane id makes the board render every card twice, once in its lane and once in "Uncategorized" (objectui#8993). When a lane carries `cards`, each card is judged — a card with no `title` is refused. An undeclared lane key is accepted and dropped, not refused, which is this tolerant face's posture; the strict authoring face refuses it by name.
 >
-> ⚠️ The **bare-string array is accepted but inert on this block.** It is declared so this package does not refuse an authoring the protocol allows. The renderer reads a bare-string lane list only when a board has no `groupBy`, and `groupBy` is required here — so on `object-kanban` the strings are always ignored and the lanes come from the group field's picklist options or from the data. Write the `{ id, title }` array to control the lanes. The requiredness of `groupBy` is tracked as objectui#8990.
+> ⚠️ The **bare-string array applies only to a board with no `groupBy`.** It is declared so this package does not refuse an authoring the protocol allows. The renderer reads a bare-string lane list only when a board has no `groupBy` — so on a board that *does* declare one the strings are ignored and the lanes come from the group field's picklist options or from the data. Since objectui#8990 made `groupBy` optional, a lane-less board is a valid authoring and this arm is live on it: the lanes are drawn, titled by the **raw strings** (a grouped board titles its lanes with the picklist *labels* instead). ⚠️ Such a board holds **no cards** — with no lane key the records are never distributed — and dragging a card writes nothing back. It is lane headings, not a populated board; to control the lanes of a working board, declare `groupBy` and write the `{ id, title }` array.
 >
 > The other keys the retired `kanban` arm alone declared — `cardTitle`, `swimlaneField`, `grouping` and `navigation` — are still undeclared on this face. The renderer reads them, so a board may carry them; they are simply not judged. The board's React host supplies `onCardMove` / `onCardClick` / `onQuickAdd` as props; none of the three is authorable in JSON.
 
-> `data` and `bind` are [`BaseSchema`](#baseschema) members, not narrowed here, but this face requires **one of** `bind`, `data`, `objectName` — the renderer's own record-source ladder (an external `data` prop → `bind` via `useDataScope` → this schema's own `data` → a fetch keyed by `objectName`). A purely static board (lanes carrying their own cards, no record source) authors `"groupBy"` and `"data": []`.
+> `data` and `bind` are [`BaseSchema`](#baseschema) members, not narrowed here, but this face requires **one of** `bind`, `data`, `objectName` — the renderer's own record-source ladder (an external `data` prop → `bind` via `useDataScope` → this schema's own `data` → a fetch keyed by `objectName`). A purely static board (lanes carrying their own cards, no record source) authors `"groupBy"` and `"data": []`. ⚠️ The record-source rule is **separate** from the lane key and is unaffected by objectui#8990: omitting `groupBy` is fine, omitting all of `bind` / `data` / `objectName` is still refused, at the refinement rather than at `groupBy`.
 
 **Related:** [ObjectViewSchema](#objectviewschema), [ObjectGridSchema](#objectgridschema)
 
 
@@ -94,13 +94,19 @@ and only a static board writes a lane's cards itself. Both faces of
 validated: a card with no `title` is refused.
 
 <Callout type="warn">
-  **The bare-string array is accepted but has no effect on `object-kanban`.** It is
+  **The bare-string array applies only to a board with no `groupBy`.** It is
   declared so this package does not refuse an authoring `@objectstack/spec` allows.
-  The renderer only reads a bare-string lane list when a board has **no** `groupBy`
-  — and `groupBy` is required on `object-kanban`, so on this block the strings are
-  always ignored and the lanes come from the group field's picklist options or from
-  the data. Write the `{ id, title }` array to control the lanes. The requiredness of
-  `groupBy` is tracked as objectui#8990.
+  The renderer only reads a bare-string lane list when a board has **no** `groupBy`,
+  so on a board that declares one the strings are ignored and the lanes come from
+  the group field's picklist options or from the data.
+
+  Since objectui#8990 made `groupBy` **optional** (matching `@objectstack/spec`), a
+  lane-less board is a valid authoring and this arm is live on it: the lanes are
+  drawn, titled by the **raw strings** — where a grouped board titles its lanes with
+  the picklist **labels**. ⚠️ A lane-less board holds **no cards**: with no lane key
+  the records are never distributed into lanes, and dragging a card writes nothing
+  back. It is lane headings, not a populated board. To control the lanes of a
+  working board, declare `groupBy` and write the `{ id, title }` array.
 </Callout>
 
 ```plaintext
 
@@ -45,9 +45,10 @@ import '@object-ui/plugin-kanban';
 // `object-kanban`. (The STORED `NamedListView.type` value `"kanban"` is a
 // different layer and is unaffected — do not rewrite saved views.)
 //
-// `groupBy` and ONE record source (`data`, `bind` or `objectName`) are what the
-// surviving face requires of every board; the shape below is the one the
-// catalog fixture `plugin-kanban/basic-kanban-board.json` carries.
+// ONE record source (`data`, `bind` or `objectName`) is what the surviving face
+// requires of every board; `groupBy` is OPTIONAL since objectui#8990 but is what
+// makes the lanes hold cards, so every working board authors it. The shape below
+// is the one the catalog fixture `plugin-kanban/basic-kanban-board.json` carries.
 const schema = {
   type: 'object-kanban',
   groupBy: 'status',
@@ -106,8 +107,9 @@ const column: KanbanColumn = {
 };
 
 // ⚠️ `object-kanban`: the bare `kanban` node type key and its `KanbanSchema`
-// arm RETIRED in objectui#8802. `groupBy` and one of `bind` / `data` /
-// `objectName` are what the surviving face requires of every board.
+// arm RETIRED in objectui#8802. One of `bind` / `data` / `objectName` is what the
+// surviving face requires of every board; `groupBy` is optional since
+// objectui#8990, and authored here because a board without it holds no cards.
 const schema: ObjectKanbanSchema = {
   type: 'object-kanban',
   groupBy: 'status',
@@ -123,9 +125,14 @@ import type { ObjectKanbanSchema } from '@object-ui/types';
 
 declare const columns: KanbanColumn[];
 
-// The board document. `type` and `groupBy` are required, and so is ONE record
-// source — `bind`, `data` or `objectName`. `columns` and `className` are
-// optional.
+// The board document. `type` is required, and so is ONE record source — `bind`,
+// `data` or `objectName`. `groupBy`, `columns` and `className` are optional.
+//
+// `groupBy` is OPTIONAL since objectui#8990, matching `@objectstack/spec`. It is
+// still the key that makes the board work: with no lane key the records are never
+// distributed, so a lane-less board draws whatever lanes `columns` declares and
+// holds NO cards, and dragging a card writes nothing back. Omitting it is valid,
+// not useful — author it on any board meant to group records.
 //
 // ⚠️ `onCardMove` is NOT a document key: it is a React prop the host supplies
 // (JSON has no function value), which is why it is spelled with explicit
@@ -136,7 +143,7 @@ declare const columns: KanbanColumn[];
 // not what catches a misspelt board key.
 const board: ObjectKanbanSchema = {
   type: 'object-kanban',
-  groupBy: 'status',                  // required — the field that makes the lanes
+  groupBy: 'status',                  // optional, but the field that makes the lanes
   data: [],                           // one record source is required
   columns,                            // Array of columns
   className: 'h-full',                // Tailwind classes
 
@@ -28,7 +28,11 @@
  * `effectiveColumns` memo). While `groupBy` was REQUIRED, no schema-valid
  * document could reach that branch: objectui#8913 admitted the arm anyway
  * (refusing it would have been a second narrowing) and recorded it as
- * unreachable. Making `groupBy` optional is what makes it live.
+ * unreachable. Making `groupBy` optional is what makes it reachable BY A
+ * SCHEMA-VALID DOCUMENT — the qualifier matters, and the section headed "WHICH
+ * legs guard the widening" below is where it is measured: the RENDERER never
+ * consulted this package's validator, so the branch was always live for a
+ * document that reached it unvalidated. ⛔ Not "dead code that came alive".
  *
  * ⚠️ "The arm fires" is not observable from the lane COUNT alone — a grouped
  * board draws two lanes too. It is observable from the lane TITLES, and that is
@@ -77,9 +81,10 @@
  * lane below it. A lane-less board returns before reaching any of it, and the
  * picklist-materialised lanes whose ids come straight from `opt.value` are
  * built under `if (schema.groupBy && ...)`, a branch a lane-less board cannot
- * enter. ⇒ This card can only NARROW objectui#8993's reachable set on the
- * documents it newly admits, never widen it. ⛔ Nothing here fixes #8993; it is
- * a renderer behaviour change with its own card.
+ * enter. ⇒ objectui#8993's reachable set is UNCHANGED by this card: admitting
+ * documents cannot shrink it, and none of the documents newly admitted can reach
+ * the defect. ⛔ Not "narrowed" — the claim is that nothing was widened. ⛔ And
+ * nothing here fixes #8993; it is a renderer behaviour change with its own card.
  */
 
 import React from 'react';
 
@@ -2928,11 +2928,12 @@ export interface ObjectKanbanSchema extends BaseSchema {
    * from-data branch), `persistCardMove`, and the `handleCardMove` callback —
    * plus their effect deps.
    *
-   * ⚠️ Anchored by SYMBOL, deliberately. The docblock this replaces cited
-   * `:601` / `:613` / `:625` / `:640` / `:747` / `:865`; every one of those had
-   * rotted by the time this card re-derived them (the same reads now sit ~370
-   * lines lower). `check:new-cross-file-line-citations` says the same thing in
-   * its own words — shifting an already-false address by a hunk delta just
+   * ⚠️ Anchored by SYMBOL, deliberately. The docblock this replaces carried six
+   * bare line addresses into that file and EVERY ONE had rotted by the time this
+   * card re-derived them — the same reads now sit some 370 lines lower. The
+   * numbers are not restated here even as history: a literal address in prose is
+   * the thing that rots, and `check:new-cross-file-line-citations` says the same
+   * in its own words — shifting an already-false address by a hunk delta only
    * moves a wrong pointer somewhere else. Undeclared here until
    * objectui#7322, so an authored value reached the renderer only through
    * {@link BaseSchema}'s `[key: string]: any` — admitted, never examined.
@@ -2954,17 +2955,31 @@ export interface ObjectKanbanSchema extends BaseSchema {
    *
    *   1. `content/docs/utilities/data-objectstack.mdx` documents an
    *      `object-kanban` node that is exactly `{ type, dataSource }` — no
-   *      `groupBy`. The published validator refused this repository's own
-   *      documented example.
+   *      `groupBy`. ⚠️ WEAKER THAN IT LOOKS, and the limit is worth stating: that
+   *      fragment is STILL refused after this card, at `RECORD_SOURCE_REQUIRED`
+   *      — `dataSource` is not a rung of this ladder — so it is evidence that a
+   *      lane-less board is a DOCUMENTED AUTHORING, not a document this card
+   *      admits. ⛔ Do not cite it as "objectui refuses its own documented
+   *      example" without that qualifier; the record-source half of the refusal
+   *      is deliberate and survives.
    *   2. `packages/plugin-list/src/ListView.tsx` GENERATES the node with
    *      `groupBy: laneField`, where
-   *      `laneField = groupByField || groupField || detectStatusField(objectDef) || undefined`
-   *      — an explicit `|| undefined`. A view that declares no lane field and
-   *      whose object has no detectable status field emits `groupBy: undefined`
-   *      at runtime, which the renderer serves and both faces refused.
-   *
-   * Same shape as {@link objectName} (objectui#7780): a key the renderer guards
-   * at every read, declared REQUIRED, refusing boards that render today.
+   *      `laneField = groupByField || groupField || detectStatusField(objectDef) || undefined`.
+   *      ⭐ This is the load-bearing one, and it is stronger than the explicit
+   *      `|| undefined` alone suggests: `objectDef` loads ASYNCHRONOUSLY, so
+   *      `laneField` is `undefined` on EVERY load until it lands — transiently
+   *      for every list-view kanban — and PERSISTENTLY in two cases from
+   *      `detectStatusField` (`packages/types/src/record-semantics.ts`): the
+   *      object declares no `stageField` role AND carries no field named
+   *      `status` / `stage` / `state` / `phase` and none typed `status`/`stage`;
+   *      or it sets `stageField: false`, which suppresses detection outright
+   *      (ADR-0085 — a status-shaped field that is not a linear flow). The
+   *      renderer serves that node and both published faces refused it.
+   *
+   * ⇒ Evidence 2 carries this on its own; evidence 1 supports the authoring
+   * shape, not the accept set. Same shape as {@link objectName} (objectui#7780):
+   * a key the renderer guards at every read, declared REQUIRED, refusing boards
+   * that render today.
    *
    * ## What a lane-less board actually does — MEASURED, not argued
    *
@@ -3001,9 +3016,11 @@ export interface ObjectKanbanSchema extends BaseSchema {
    * `__uncolumned__` lane below it). A lane-less board returns before reaching
    * it, and the picklist-materialised lanes whose ids come straight from
    * `opt.value` are built under `if (schema.groupBy && ...)` — a branch a
-   * lane-less board cannot enter. So this card can only NARROW objectui#8993's
-   * reachable set on the documents it newly admits, never widen it. Measured
-   * both ways in the pin file above.
+   * lane-less board cannot enter. So objectui#8993's reachable set is UNCHANGED
+   * by this card — admitting documents cannot shrink it, and none of the
+   * documents newly admitted can reach the defect. ⛔ Not "narrowed": the
+   * containment is that nothing was widened. Measured both ways in the pin file
+   * above.
    */
   groupBy?: string;
   /**
@@ -3117,9 +3134,18 @@ export interface ObjectKanbanSchema extends BaseSchema {
    * {@link groupBy} was REQUIRED, no document that passed this schema could
    * reach that branch, and objectui#8913 admitted the arm anyway — refusing it
    * would have made objectui narrower than the protocol — recording it as
-   * inert. objectui#8990 made {@link groupBy} OPTIONAL, which is what made the
-   * arm live: a `groupBy`-less board with `columns: ['todo', 'doing']` now
-   * parses AND draws those two lanes, titled by the raw strings.
+   * inert. objectui#8990 made {@link groupBy} OPTIONAL, which is what makes the
+   * arm reachable BY A SCHEMA-VALID DOCUMENT: a `groupBy`-less board with
+   * `columns: ['todo', 'doing']` now parses AND draws those two lanes, titled by
+   * the raw strings.
+   *
+   * ⚠️ The qualifier is load-bearing, and matches {@link groupBy}'s. The RENDERER
+   * never consulted this package's validator — `SchemaRenderer` runs core's
+   * structural `validateSchema`, which carries no kanban rule — so the string
+   * branch was always live for a document that reached it WITHOUT passing the
+   * published faces (`ListView.tsx`'s generated node; any host not running
+   * `os check`). What the requiredness prevented was a document being valid AND
+   * getting there. ⛔ Do not restate this as "the arm was dead code".
    *
    * ⚠️ RAW strings, not localized labels, and the difference is the arm's
    * signature. The string branch returns `{ id: val, title: val }` and never