@@ -0,0 +1,42 @@
+---
+'@object-ui/plugin-kanban': minor
+---
+
+fix(plugin-kanban): a kanban lane matches records by its `id` only, never by its `title`
+
+⚠️ Behaviour change (narrowing), declared `minor` under this repo's fixed-group
+versioning. Executes maintainer ruling A on objectui#10069.
+
+A kanban board decides which lane a record belongs to by comparing the record's
+stored `groupBy` value with each lane's `id` — the picklist option value. Until
+now `bucketCardsIntoColumns` also lowercased every lane `title` into that lookup,
+so the title was a second, undeclared bucketing key. That had three
+user-visible effects, and all three are gone:
+
+- renaming a lane in authored `columns` moved records between lanes;
+- relabelling a picklist option moved records too, because lanes derived from
+  the `groupBy` field's options take `title: opt.label`;
+- membership depended on the viewer's locale, because lane titles are
+  translated: a record storing the English label bucketed into its lane in one
+  locale and into "Uncategorized" in another.
+
+The lane `title` is now presentation only. The id comparison keeps its existing
+case folding (`IN_PROGRESS` still matches a lane `in_progress`).
+
+A record whose value matches no lane id still surfaces in the trailing
+"Uncategorized" lane (#2792), and the board now also names it on the console:
+one `console.warn` per distinct raw value per bucketing pass, giving the
+`groupBy` field, the raw value, the number of records carrying it and the
+available lane ids. An empty group value is not warned about.
+
+**Migration.** Records whose group field stores an option's LABEL (for example
+`'In Progress'`) instead of its VALUE (`'in_progress'`) used to reach their lane
+through the retired title match; they now appear under "Uncategorized", and the
+console warning names each such value. Fix the data, not the board: update each
+record to store the option value. A drag from "Uncategorized" into the right lane
+writes the lane id and so repairs one record at a time; for a bulk repair, find
+the affected records with a filter that selects values outside the field's
+option values, e.g. `['and', ['status', 'nin', ['in_progress', 'done']],
+['status', '!=', null], ['status', '!=', '']]`, and update each to the value
+whose option label it stores. ⛔ Do not add the label as a lane `id` to make the
+records reappear: that re-teaches the label as a second value for the same state.
@@ -2424,7 +2424,7 @@ const MEMBER_PINS: Record<string, MemberPin> = {
   },
   'object-kanban.columns': {
     file: 'packages/plugin-kanban/src/__tests__/objectKanbanColumnMembers-8071.test.tsx',
-    pins: 'The SWIMLANE element\'s six members, each at its OWN sink and none assumed to behave like its neighbour, driven through the real renderer on a real adapter. `id` decides which records land in the lane (`groups[col.id]`) and names the heading, with an unmatched record swept into the trailing lane rather than dropped (objectui#2792) as the control. ⭐ `title` is read TWICE with two unrelated meanings — as the lane\'s accessible name, and as a BUCKETING ALIAS (`labelToColumnId[String(col.title).toLowerCase()] = col.id`), so a record whose stored group value is the lane\'s TITLE lands in that lane as surely as one carrying its id: nothing on the authoring surface says so, and renaming a lane therefore MOVES RECORDS. `cards` is a UNION and not a replacement — static lane cards survive the fetch, come first, and are not de-duplicated against it. `limit` is displayed beside the count and flags the lane, and ⛔ never truncates: the over-limit row asserts every card still renders, so a pin watching only the badge could not stay green under a renderer that dropped the overflow. `className` reaches that lane\'s container and no other. `collapsed` withholds that lane\'s cards while its neighbour keeps them — the member-set row only, because `columnCollapsedHonoured-9628.test.tsx` owns that member whole. The set itself is asserted as a WHITELIST: an undeclared lane member reaches no sink, with a `className` marker on the same lane in the same render as the lit control. ⚠️ The DECLARATION half is a different file and deliberately not duplicated here: `packages/types/src/__tests__/object-kanban-columns-declared-8913.test.ts` (objectui#8913/#8989) parses lane bags against both published faces, and every assertion in it is a `safeParse` — it cannot say what the board DOES with a member it admitted, which is objectui#8068\'s criterion. Read end to end before being cited. New file (objectui#8071 slice 16).',
+    pins: 'The SWIMLANE element\'s six members, each at its OWN sink and none assumed to behave like its neighbour, driven through the real renderer on a real adapter. `id` decides which records land in the lane (`groups[col.id]`) and names the heading, with an unmatched record swept into the trailing lane rather than dropped (objectui#2792) as the control. ⭐ `title` is the lane\'s accessible name and ⛔ NOT a bucketing key: it used to be a second, undeclared BUCKETING ALIAS, so renaming a lane moved records; objectui#10069 (ruling A) retired it and FLIPPED that row, so a record whose stored group value is the lane\'s TITLE is now swept into the trailing lane with a console warn. `cards` is a UNION and not a replacement — static lane cards survive the fetch, come first, and are not de-duplicated against it. `limit` is displayed beside the count and flags the lane, and ⛔ never truncates: the over-limit row asserts every card still renders, so a pin watching only the badge could not stay green under a renderer that dropped the overflow. `className` reaches that lane\'s container and no other. `collapsed` withholds that lane\'s cards while its neighbour keeps them — the member-set row only, because `columnCollapsedHonoured-9628.test.tsx` owns that member whole. The set itself is asserted as a WHITELIST: an undeclared lane member reaches no sink, with a `className` marker on the same lane in the same render as the lit control. ⚠️ The DECLARATION half is a different file and deliberately not duplicated here: `packages/types/src/__tests__/object-kanban-columns-declared-8913.test.ts` (objectui#8913/#8989) parses lane bags against both published faces, and every assertion in it is a `safeParse` — it cannot say what the board DOES with a member it admitted, which is objectui#8068\'s criterion. Read end to end before being cited. New file (objectui#8071 slice 16).',
   },
   'object-kanban.conditionalFormatting': {
     file: 'packages/plugin-kanban/src/__tests__/ObjectKanban.structuredMembersReachTheirSinks-8313.test.tsx',
 
@@ -935,7 +935,7 @@ A drag-and-drop Kanban board. The `object-kanban` type key validates the shape t
 |----------|------|-------------|
 | `objectName` | `string` | Object to fetch records from. |
 | `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. |
+| `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. A record lands in a lane when its stored `groupBy` value equals the lane **`id`** (the option value, compared case-insensitively); the lane `title` is display only and never decides membership (objectui#10069). A record matching no lane id is shown in a trailing *Uncategorized* lane and named in a console warning. |
 | `titleField` | `string` | Field used as the card title. |
 | `cardFields` | `string[]` | Fields rendered on each card. |
 | `filter` | `any[]` | Query filter, forwarded verbatim as `$filter`. |
 
@@ -160,8 +160,8 @@ const onCardMove = (cardId: string, fromColumnId: string, toColumnId: string, ne
 
 // Column structure
 interface KanbanColumn {
-  id: string;
-  title: string;
+  id: string;                         // The option VALUE — the ONLY key a record is matched on
+  title: string;                      // Display only; never decides lane membership (objectui#10069)
   cards: KanbanCard[];
   limit?: number;                     // WIP limit — the count at which the lane warns
   className?: string;
 
@@ -51,7 +51,7 @@
  * control could not catch it.
  */
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { bucketCardsIntoColumns, KANBAN_UNCOLUMNED_ID } from '../index';
 
 /** `id:card+card` per lane, in lane order — the whole board in one string. */
@@ -114,10 +114,18 @@ describe('bucketCardsIntoColumns — lane id key coercion (objectui#8993)', () =
     }
   });
 
-  it('row 4 — the label→id path is keyed the same way (it stores the RAW id)', () => {
-    // 'One' matches the lane's TITLE, so the group key comes out of
-    // `labelToColumnId`, whose stored VALUE is the raw numeric id.
-    expect(bucket([{ id: 1, title: 'One' }], [{ id: 'r1', status: 'One' }])).toBe('1:r1');
+  it('row 4 — the folded-id lookup is keyed the same way (it stores the RAW id)', () => {
+    // The string '1' reaches the lane through `laneIdByFoldedId`, whose stored
+    // VALUE is the raw numeric id. This row used to reach that lookup through
+    // the lane's TITLE ('One'); objectui#10069 retired title matching, so the
+    // title-valued record is now an orphan — asserted here so this row cannot
+    // silently go back to exercising the retired key.
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    expect(bucket([{ id: 1, title: 'One' }], [{ id: 'r1', status: '1' }])).toBe('1:r1');
+    expect(bucket([{ id: 1, title: 'One' }], [{ id: 'r1', status: 'One' }])).toBe(
+      `1:, ${KANBAN_UNCOLUMNED_ID}:r1`,
+    );
+    warn.mockRestore();
   });
 
   it('row 5 — the sweep still sweeps: an unmatched record still surfaces (#2792)', () => {
 
@@ -0,0 +1,208 @@
+/**
+ * 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.
+ */
+
+/**
+ * objectui#10069 (ruling A) — a kanban lane matches a record by lane `id`, the
+ * stored option value, ONLY. The lane `title` is presentation.
+ *
+ * Before the ruling `bucketCardsIntoColumns` also lowercased every lane
+ * `title` into its lookup, so the title was an undeclared second bucketing
+ * key. Three things moved records as a result, and each is a row here:
+ *
+ *   1. LOCALE. Lane titles are translated (`localizeColumn` and
+ *      `translateOptions` in `ObjectKanban.tsx`), so a record storing the
+ *      English label bucketed into its lane under one locale and into
+ *      "Uncategorized" under another. Membership must not depend on titles.
+ *   2. THE PICKLIST DOOR. With no authored `columns`, lanes are derived from
+ *      the groupBy field's options as `{ id: opt.value, title: opt.label }`,
+ *      so relabelling an option moved records too. Driven through the real
+ *      renderer, because that door lives in `ObjectKanban`, not in the pure
+ *      bucketer. (The authored-`columns` door is the flipped row in
+ *      `objectKanbanColumnMembers-8071.test.tsx`.)
+ *   3. LOUDNESS. A record that no longer matches is a DATA defect (it stored a
+ *      label instead of the value), so the move into "Uncategorized" is
+ *      named on the console — once per distinct raw value per bucketing pass.
+ */
+
+import React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, waitFor, cleanup } from '@testing-library/react';
+import { SchemaRenderer, SchemaRendererProvider } from '@object-ui/react';
+// Registers `object-kanban`; module scope because the import IS the
+// registration (AGENTS.md's test-discipline section).
+import { bucketCardsIntoColumns, KANBAN_UNCOLUMNED_ID } from '../index';
+// Same specifier as `index.tsx`'s `React.lazy` factory, imported at module
+// scope so the cold transform is billed to the import phase (objectui#3010).
+import '../KanbanImpl';
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+/** `id:card+card` per lane, in lane order. */
+const summarise = (lanes: Array<any>): string =>
+  lanes.map((l: any) => `${String(l.id)}:${(l.cards || []).map((c: any) => c.id).join('+')}`).join(', ');
+
+const bucket = (columns: Array<any>, data: Array<any>) =>
+  bucketCardsIntoColumns(columns, data, 'status', undefined, 'Uncategorized');
+
+const RECORDS = [
+  { id: 'r1', status: 'in_progress' }, // the option VALUE
+  { id: 'r2', status: 'In Progress' }, // the English LABEL
+  { id: 'r3', status: 'done' },
+];
+
+describe('objectui#10069 — lane membership is decided by lane id only', () => {
+  it('⭐ a translated title does not change membership', () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const english = [
+      { id: 'in_progress', title: 'In Progress' },
+      { id: 'done', title: 'Done' },
+    ];
+    const german = [
+      { id: 'in_progress', title: 'In Bearbeitung' },
+      { id: 'done', title: 'Erledigt' },
+    ];
+
+    const underEnglish = summarise(bucket(english, RECORDS));
+    const underGerman = summarise(bucket(german, RECORDS));
+
+    // Same ids, different titles ⇒ the same board. Before the ruling the
+    // English run put r2 in `in_progress` and the German run swept it.
+    expect(underEnglish).toBe(underGerman);
+    expect(underEnglish).toBe(`in_progress:r1, done:r3, ${KANBAN_UNCOLUMNED_ID}:r2`);
+  });
+
+  it('CONTROL — the id comparison keeps its case folding', () => {
+    // The ruling retires the TITLE key only; an id spelled in another case
+    // still lands, so the row above is about titles and not about folding.
+    expect(summarise(bucket([{ id: 'in_progress', title: 'In Progress' }], [{ id: 'r1', status: 'IN_PROGRESS' }]))).toBe(
+      'in_progress:r1',
+    );
+  });
+
+  describe('the console warn', () => {
+    const LANES = [
+      { id: 'open', title: 'Open' },
+      { id: 'won', title: 'Won' },
+    ];
+
+    it('names the raw value, the grouping field and every available lane id', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      bucket(LANES, [{ id: 'r1', status: 'Opened' }]);
+
+      expect(warn).toHaveBeenCalledTimes(1);
+      const message = String(warn.mock.calls[0][0]);
+      expect(message).toContain('"Opened"');
+      expect(message).toContain('"status"');
+      expect(message).toContain('["open", "won"]');
+    });
+
+    it('fires ONCE per distinct raw value per pass, not once per record', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      bucket(LANES, [
+        { id: 'r1', status: 'Opened' },
+        { id: 'r2', status: 'Opened' },
+        { id: 'r3', status: 'Opened' },
+        { id: 'r4', status: 'Closed Won' },
+        { id: 'r5', status: 'OPEN' }, // matched (case-folded id): no warn
+      ]);
+
+      expect(warn).toHaveBeenCalledTimes(2);
+      const messages = warn.mock.calls.map((c) => String(c[0]));
+      expect(messages.find((m) => m.includes('"Opened"'))).toContain('3 record(s)');
+      expect(messages.find((m) => m.includes('"Closed Won"'))).toContain('1 record(s)');
+
+      // A second pass (the next render or data load) warns again: deduplication
+      // is per pass, never module-wide, so a later board is not silenced.
+      bucket(LANES, [{ id: 'r1', status: 'Opened' }]);
+      expect(warn).toHaveBeenCalledTimes(3);
+    });
+
+    it('stays silent when every record matches, and for an EMPTY group value', () => {
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const out = bucket(LANES, [
+        { id: 'r1', status: 'open' },
+        { id: 'r2', status: '' },
+        { id: 'r3' },
+      ]);
+
+      // The empty-valued records still surface (#2792) — only the warn is withheld.
+      expect(summarise(out)).toBe(`open:r1, won:, ${KANBAN_UNCOLUMNED_ID}:r2+r3`);
+      expect(warn).not.toHaveBeenCalled();
+    });
+  });
+});
+
+/* -------------------------------------------------------------------------- */
+/* The picklist door — lanes derived from `field.options`, no `columns`        */
+/* -------------------------------------------------------------------------- */
+
+const OBJECT = 'deal';
+
+const DEAL_SCHEMA = {
+  name: OBJECT,
+  label: 'Deal',
+  fields: {
+    name: { type: 'text', label: 'Name' },
+    status: {
+      type: 'select',
+      label: 'Status',
+      options: [
+        { value: 'in_progress', label: 'In Progress' },
+        { value: 'done', label: 'Done' },
+      ],
+    },
+  },
+};
+
+function makeAdapter(rows: Array<Record<string, unknown>>): Record<string, any> {
+  return {
+    find: vi.fn(async () => ({ data: rows })),
+    findOne: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    getObjectSchema: vi.fn(async () => DEAL_SCHEMA),
+  };
+}
+
+const cardsInList = (container: HTMLElement, label: string): string[] =>
+  [...(container.querySelector(`[role="list"][aria-label="${label}"]`)?.children ?? [])]
+    .map((node) => node.getAttribute('aria-label') ?? '')
+    .filter((name) => name !== '');
+
+const laneNames = (container: HTMLElement): string[] =>
+  [...container.querySelectorAll('[role="group"]')].map((n) => n.getAttribute('aria-label') ?? '');
+
+describe('objectui#10069 — the picklist door (`title: opt.label`) no longer buckets by label', () => {
+  it('⭐ a record storing an option LABEL is swept; the one storing its VALUE lands', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const adapter = makeAdapter([
+      { id: 'a', name: 'By value', status: 'in_progress' },
+      { id: 'b', name: 'By label', status: 'In Progress' },
+    ]);
+    const { container } = render(
+      <SchemaRendererProvider dataSource={adapter as any}>
+        <SchemaRenderer schema={{ type: 'object-kanban', objectName: OBJECT, groupBy: 'status' } as never} />
+      </SchemaRendererProvider>,
+    );
+
+    // Wait on the CARD, not the lane: lanes commit before the query settles.
+    await waitFor(() => expect(cardsInList(container, 'In Progress cards')).toEqual(['By value']));
+    // The lanes really were derived from the picklist (titles are the labels),
+    // plus the trailing sweep holding the label-valued record.
+    expect(laneNames(container).slice(0, 2)).toEqual(['In Progress', 'Done']);
+    expect(laneNames(container)).toHaveLength(3);
+    expect(cardsInList(container, `${laneNames(container)[2]} cards`)).toEqual(['By label']);
+    expect(
+      warn.mock.calls.some((c) => String(c[0]).includes('"In Progress"') && String(c[0]).includes('"in_progress", "done"')),
+    ).toBe(true);
+  });
+});