diff --git a/.railwayignore b/.railwayignore
new file mode 100644
index 00000000..70b2b7aa
--- /dev/null
+++ b/.railwayignore
@@ -0,0 +1,4 @@
+.theorem/
+.git/
+test-results/
+**/*.spec.ts-snapshots/
diff --git a/apps/console/e2e/cards.spec.ts b/apps/console/e2e/cards.spec.ts
new file mode 100644
index 00000000..0935140b
--- /dev/null
+++ b/apps/console/e2e/cards.spec.ts
@@ -0,0 +1,253 @@
+// SOURCING: @playwright/test. The cards/actions/mentions oracles
+// (HANDOFF-CARDS-ACTIONS-MENTIONS K7): live person and task cards render
+// through their templates, relation chips navigate, the three sheet entries
+// open one identical sheet, the submitted pack equals the visible chip set
+// exactly (the named invariant probe of the round), and the mentions
+// round-trip confirms and suppresses through the seam. Baselines capture the
+// grid, the full card, and the sheet.
+
+import { expect, test, type Page } from '@playwright/test';
+
+async function settled(page: Page) {
+  await page.waitForSelector('[data-shell]');
+  await page.waitForTimeout(600);
+}
+
+async function freshLoad(page: Page) {
+  await page.goto('/');
+  await page.evaluate(() => window.localStorage.removeItem('commonplace.console.surface.v1'));
+  await page.reload();
+  await settled(page);
+}
+
+async function openSurface(page: Page, surfaceId: string) {
+  // Screen navigation is the leftmost stripe's surfaces group.
+  await page.locator(`[data-surface-nav="${surfaceId}"]`).click();
+  await expect(page.locator('[data-shell]')).toHaveAttribute('data-active-surface', surfaceId);
+}
+
+test.describe('cards, actions, mentions', () => {
+  test.beforeEach(async ({ page }) => {
+    await freshLoad(page);
+  });
+
+  test('the surface rail is the primary nav: far-left, switches screens', async ({ page }) => {
+    const rail = page.locator('[data-surface-rail]');
+    await expect(rail).toBeVisible();
+    // Every seeded surface has a rail entry; the active one marks aria-current.
+    await expect(rail.locator('[data-surface-nav]')).toHaveCount(5);
+    await expect(rail.locator('[data-surface-nav="console-workspace"]')).toHaveAttribute(
+      'aria-current',
+      'page',
+    );
+    // Clicking a rail entry switches the surface without the toolbar dropdown.
+    await rail.locator('[data-surface-nav="console-cards"]').click();
+    await expect(page.locator('[data-shell]')).toHaveAttribute('data-active-surface', 'console-cards');
+    await expect(rail.locator('[data-surface-nav="console-cards"]')).toHaveAttribute(
+      'aria-current',
+      'page',
+    );
+  });
+
+  test('the grid renders live person and task cards through their templates', async ({ page }) => {
+    await openSurface(page, 'console-cards');
+    const person = page.locator('[data-card-kind="person"]');
+    await expect(person).toBeVisible();
+    await expect(person.getByText('Ada Lovelace')).toBeVisible();
+    await expect(person.getByText('Analyst')).toBeVisible();
+    await expect(page.locator('[data-card-kind="task"]')).toBeVisible();
+    // Objects of a kind with no template render the generic card, never an
+    // error: the org and project cells are present as generic faces.
+    await expect(page.locator('[data-card-cell="org-braintrust"] [data-card-kind="generic"]')).toBeVisible();
+  });
+
+  test('relation chips are live objects: a chip opens the related card', async ({ page }) => {
+    await openSurface(page, 'console-cards');
+    await page.locator('[data-card-chip="WORKS_AT"]').first().click();
+    const inspector = page.getByLabel('Record inspector');
+    await expect(inspector).toBeVisible();
+    await expect(inspector.getByText('Braintrust').first()).toBeVisible();
+    // The related org has no template of its own: generic card, never an error.
+    await expect(inspector.locator('[data-card-kind="generic"]')).toBeVisible();
+  });
+
+  test('the full card renders through the descriptor registry with gauge and facts', async ({ page }) => {
+    // The arrangement is data: seed a surface hosting card.full over the live
+    // task query, exactly as a user arrangement would.
+    await page.evaluate(() => {
+      const raw = window.localStorage.getItem('commonplace.console.surface.v1');
+      const objects = raw ? JSON.parse(raw) : [];
+      const filtered = objects.filter(
+        (o: { id: string }) => !['e2e-card-surface', 'e2e.region', 'e2e.vi-card'].includes(o.id),
+      );
+      for (const object of filtered) {
+        if (object.type === 'surface') object.properties.active = false;
+      }
+      filtered.push(
+        { id: 'e2e-card-surface', type: 'surface', properties: { name: 'CardProof', kind: 'workspace', active: true }, relations: { CONTAINS: ['e2e.region'] } },
+        { id: 'e2e.region', type: 'region', properties: { kind: 'editor', size: 100, active_tab: 'e2e.vi-card' }, relations: { CONTAINS: ['e2e.vi-card'] } },
+        { id: 'e2e.vi-card', type: 'view-instance', properties: { descriptor_id: 'card.full', title: 'Task card', query: { types: ['task'], page: { limit: 1 } } }, relations: { CONTAINS: [] } },
+      );
+      window.localStorage.setItem('commonplace.console.surface.v1', JSON.stringify(filtered));
+    });
+    await page.reload();
+    await settled(page);
+    const card = page.locator('[data-card="full"]');
+    // The injected surface's card.full queries the task over the live wire on
+    // a freshly compiled route; allow headroom so a cold, parallel-loaded dev
+    // server does not flake this behavioral assertion.
+    await expect(card).toBeVisible({ timeout: 15000 });
+    await expect(card.getByText('Send the compliance report')).toBeVisible();
+    await expect(card.getByRole('progressbar')).toHaveAttribute('aria-valuenow', '40');
+    await expect(card.getByText('high')).toBeVisible();
+    await expect(card.locator('[data-card-chip="IN_PROJECT"]')).toBeVisible();
+  });
+
+  test('the grid virtualizes past 200 cards', async ({ page }) => {
+    await page.evaluate(() => {
+      const raw = window.localStorage.getItem('commonplace.console.surface.v1');
+      const objects = raw ? JSON.parse(raw) : [];
+      for (const object of objects) {
+        if (object.type === 'surface') object.properties.active = false;
+      }
+      objects.push(
+        { id: 'e2e-grid-surface', type: 'surface', properties: { name: 'GridProof', kind: 'workspace', active: true }, relations: { CONTAINS: ['e2e.grid-region'] } },
+        { id: 'e2e.grid-region', type: 'region', properties: { kind: 'editor', size: 100, active_tab: 'e2e.vi-grid' }, relations: { CONTAINS: ['e2e.vi-grid'] } },
+        { id: 'e2e.vi-grid', type: 'view-instance', properties: { descriptor_id: 'cards.grid', title: 'Grid proof', query: { types: ['record'], page: { limit: 400 } } }, relations: { CONTAINS: [] } },
+      );
+      window.localStorage.setItem('commonplace.console.surface.v1', JSON.stringify(objects));
+    });
+    await page.reload();
+    await settled(page);
+    await expect(page.locator('[data-cards-grid]')).toBeVisible();
+    const rendered = await page.locator('[data-card-cell]').count();
+    expect(rendered).toBeGreaterThan(0);
+    expect(rendered).toBeLessThan(400);
+    // Keyboard focus order is row-major: the first two cells are adjacent in
+    // tab order because the DOM order is row-major.
+    await page.locator('[data-card-cell]').first().focus();
+    await page.keyboard.press('Tab');
+    const secondId = await page.locator('[data-card-cell]').nth(1).getAttribute('data-card-cell');
+    const focusedId = await page.evaluate(() =>
+      document.activeElement?.getAttribute('data-card-cell'),
+    );
+    expect(focusedId).toBe(secondId);
+  });
+
+  test('all three entries open the identical sheet; the pack equals the chips', async ({ page }) => {
+    // Entry 1: the Action verb from the inspector. Click the title text: a
+    // center-click can land on a relation chip, which is its own navigation.
+    await openSurface(page, 'console-cards');
+    await page.locator('[data-card-cell="person-ada"]').getByText('Ada Lovelace').click();
+    await page.locator('[data-inspector-action]').click();
+    const sheet = page.locator('[data-action-sheet]');
+    await expect(sheet).toBeVisible();
+    await expect(sheet.locator('[data-context-chip="origin"]')).toContainText('Ada Lovelace');
+
+    // The no-silent-context probe (the named invariant test of the round):
+    // capture the submitted pack and compare it to the visible chips exactly.
+    await sheet.getByLabel('Instruction').fill('review the memoir margins');
+    const visibleChips = await sheet.locator('[data-context-chip]').allTextContents();
+    const packPromise = page.waitForRequest('**/api/harness/delegate');
+    await sheet.getByRole('button', { name: 'Hand off' }).click();
+    const request = await packPromise;
+    const pack = request.postDataJSON() as {
+      instruction: string;
+      context: Array<{ label: string }>;
+    };
+    expect(pack.instruction).toBe('review the memoir margins');
+    expect(pack.context.length).toBe(visibleChips.length);
+    expect(pack.context[0].label).toBe('Ada Lovelace');
+    for (const entry of pack.context) {
+      expect(visibleChips.some((text) => text.includes(entry.label))).toBe(true);
+    }
+    // With the harness delegate unconfigured in e2e, For me renders the
+    // named unavailable state and With me remains available (K4).
+    await expect(sheet.locator('[data-delegate-refused]')).toContainText('CONSOLE_HARNESS_URL');
+    await sheet.locator('[data-destination="with-me"]').click();
+    await sheet.getByRole('button', { name: 'Stage in thread' }).click();
+    await expect(page.locator('[data-action-sheet]')).toHaveCount(0);
+    // Close the inspector: it overlays the right edge of every surface and
+    // would intercept the docs entry's todo affordance below.
+    await page.getByLabel('Close inspector').click();
+
+    // Entry 2: /do in the composer opens the same sheet, pre-filled.
+    await openSurface(page, 'console-workspace');
+    const composer = page.locator('[data-thread-composer-input]');
+    await expect(composer).toBeVisible();
+    // The With-me staging from entry 1 is visible above the composer.
+    await expect(page.locator('[data-thread-staged-ref]').first()).toContainText('Ada Lovelace');
+    await composer.fill('/do triage the inbox');
+    await composer.press('Enter');
+    await expect(page.locator('[data-action-sheet]')).toBeVisible();
+    await expect(page.getByLabel('Instruction')).toHaveValue('triage the inbox');
+    await page.keyboard.press('Escape');
+
+    // Entry 3: the todo-block action icon in a document, and Alt+Enter.
+    await openSurface(page, 'console-docs');
+    await page.locator('[data-doc-id="doc-console-punch-list"]').click();
+    const todoButton = page.locator('[data-todo-action]').first();
+    await expect(todoButton).toBeVisible();
+    await todoButton.click();
+    const todoSheet = page.locator('[data-action-sheet]');
+    await expect(todoSheet).toBeVisible();
+    await expect(todoSheet.locator('[data-context-chip="origin"]').first()).toContainText(
+      'Console punch list',
+    );
+    await page.keyboard.press('Escape');
+    await page.locator('li.task-list-item').first().focus();
+    await page.keyboard.press('Alt+Enter');
+    await expect(page.locator('[data-action-sheet]')).toBeVisible();
+    // Save as rule names its missing capability (IX6) instead of pretending.
+    await expect(page.locator('[data-save-as-rule-unavailable]')).toContainText('IX6');
+  });
+
+  test('mentions: truthful counts, confirm writes through, dismiss suppresses', async ({ page }) => {
+    await openSurface(page, 'console-cards');
+    const adaCell = page.locator('[data-card-cell="person-ada"]');
+    await expect(adaCell.locator('[data-mentions-chip]')).toHaveText('2');
+    // An object with no candidates shows no mentions chrome at all.
+    await expect(
+      page.locator('[data-card-cell="task-report"] [data-mentions-section]'),
+    ).toHaveCount(0);
+
+    await adaCell.getByText('Ada Lovelace').click();
+    const inspector = page.getByLabel('Record inspector');
+    const summary = inspector.locator('[data-mentions-summary]');
+    await expect(summary).toContainText('mentioned in 2 places, 2 unlinked');
+    await inspector.locator('[data-mentions-section] button').first().click();
+    // The passage highlight matches the recorded span exactly.
+    await expect(inspector.locator('[data-mention-span]').first()).toHaveText('Ada Lovelace');
+
+    await inspector.getByRole('button', { name: 'Confirm' }).first().click();
+    await expect(summary).toContainText('1 unlinked');
+    await expect(inspector.locator('[data-mention-candidate="confirmed"]')).toHaveCount(1);
+
+    await inspector.getByRole('button', { name: 'Dismiss' }).first().click();
+    await expect(summary).toContainText('mentioned in 1 places, 0 unlinked');
+  });
+
+  test('baselines: grid, full card, and the sheet under reduced motion', async ({ page }) => {
+    await page.emulateMedia({ reducedMotion: 'reduce' });
+    await page.setViewportSize({ width: 1440, height: 900 });
+    await freshLoad(page);
+    await openSurface(page, 'console-cards');
+    await page.waitForTimeout(400);
+    await expect(page.locator('[data-cards-grid]')).toHaveScreenshot('cards-grid.png');
+
+    await page.locator('[data-card-cell="person-ada"]').click();
+    await page.waitForTimeout(400);
+    await expect(
+      page.getByLabel('Record inspector').locator('[data-card="compact"]'),
+    ).toHaveScreenshot('card-compact-inspector.png');
+
+    await page.locator('[data-inspector-action]').click();
+    const sheet = page.locator('[data-action-sheet]');
+    await expect(sheet).toBeVisible();
+    await page.waitForTimeout(300);
+    // Reduced motion renders the sheet without the material animation.
+    const transform = await sheet.evaluate((el) => getComputedStyle(el).transform);
+    expect(['none', 'matrix(1, 0, 0, 1, 0, 0)']).toContain(transform);
+    await expect(sheet).toHaveScreenshot('action-sheet.png');
+  });
+});
diff --git a/apps/console/e2e/cards.spec.ts-snapshots/action-sheet-darwin.png b/apps/console/e2e/cards.spec.ts-snapshots/action-sheet-darwin.png
new file mode 100644
index 00000000..d5fa8f2f
Binary files /dev/null and b/apps/console/e2e/cards.spec.ts-snapshots/action-sheet-darwin.png differ
diff --git a/apps/console/e2e/cards.spec.ts-snapshots/action-sheet-linux.png b/apps/console/e2e/cards.spec.ts-snapshots/action-sheet-linux.png
new file mode 100644
index 00000000..87b92374
Binary files /dev/null and b/apps/console/e2e/cards.spec.ts-snapshots/action-sheet-linux.png differ
diff --git a/apps/console/e2e/cards.spec.ts-snapshots/card-compact-inspector-darwin.png b/apps/console/e2e/cards.spec.ts-snapshots/card-compact-inspector-darwin.png
new file mode 100644
index 00000000..006ad75e
Binary files /dev/null and b/apps/console/e2e/cards.spec.ts-snapshots/card-compact-inspector-darwin.png differ
diff --git a/apps/console/e2e/cards.spec.ts-snapshots/card-compact-inspector-linux.png b/apps/console/e2e/cards.spec.ts-snapshots/card-compact-inspector-linux.png
new file mode 100644
index 00000000..003535de
Binary files /dev/null and b/apps/console/e2e/cards.spec.ts-snapshots/card-compact-inspector-linux.png differ
diff --git a/apps/console/e2e/cards.spec.ts-snapshots/cards-grid-darwin.png b/apps/console/e2e/cards.spec.ts-snapshots/cards-grid-darwin.png
new file mode 100644
index 00000000..833ccae7
Binary files /dev/null and b/apps/console/e2e/cards.spec.ts-snapshots/cards-grid-darwin.png differ
diff --git a/apps/console/e2e/cards.spec.ts-snapshots/cards-grid-linux.png b/apps/console/e2e/cards.spec.ts-snapshots/cards-grid-linux.png
new file mode 100644
index 00000000..b30c508d
Binary files /dev/null and b/apps/console/e2e/cards.spec.ts-snapshots/cards-grid-linux.png differ
diff --git a/apps/console/e2e/hunk-review.spec.ts b/apps/console/e2e/hunk-review.spec.ts
index 54c18c5f..5993aef3 100644
--- a/apps/console/e2e/hunk-review.spec.ts
+++ b/apps/console/e2e/hunk-review.spec.ts
@@ -1,16 +1,17 @@
 // SOURCING: @playwright/test. Hunk visual milestone: the typed review route
 // resolves through the Greenfield surface registry and Int UI register.
 
-import { expect, test } from '@playwright/test';
+import { expect, test, type Page } from '@playwright/test';
 
-async function openReview(page: import('@playwright/test').Page) {
+async function openReview(page: Page) {
   await page.goto('/');
   await page.evaluate(() => window.localStorage.removeItem('commonplace.console.surface.v1'));
   await page.reload();
   await page.setViewportSize({ width: 1440, height: 900 });
   await page.emulateMedia({ reducedMotion: 'reduce' });
-  await page.getByRole('button', { name: 'Layout: Workspace' }).click();
-  await page.getByRole('option', { name: 'Review' }).click();
+  // Screen navigation is the leftmost stripe's surfaces group (the toolbar
+  // dropdown was replaced by the stripe surfaces group).
+  await page.locator('[data-surface-nav="console-review"]').click();
   await expect(page.locator('[data-active-surface="console-review"]')).toBeVisible();
   await expect(page.getByTestId('hunk-review')).toBeVisible();
 }
diff --git a/apps/console/e2e/omnibar.spec.ts b/apps/console/e2e/omnibar.spec.ts
index 29b2f20b..252a31c3 100644
--- a/apps/console/e2e/omnibar.spec.ts
+++ b/apps/console/e2e/omnibar.spec.ts
@@ -35,7 +35,8 @@ test.describe('omnibar island', () => {
     await page.keyboard.press('Escape');
     await expect(page.locator('[data-omnibar-island]')).toHaveCount(0);
 
-    // Command-palette convention: Ctrl+K opens Ask too.
+    // Command-palette convention: Ctrl+K opens Ask too (the browser-reliable
+    // key, since Ctrl/Cmd+L is reserved by browsers for the address bar).
     await page.keyboard.press('Control+k');
     await expect(page.locator('[data-omnibar-island]')).toBeVisible();
     await expect(page.locator('[data-omnibar-mode="ask"]')).toHaveAttribute('aria-pressed', 'true');
@@ -136,30 +137,54 @@ test.describe('omnibar island', () => {
     await expect(page.locator('[data-shell]')).toHaveAttribute('data-active-surface', 'console-index');
   });
 
-  test('layout switcher round-trips surfaces with their own arrangements', async ({ page }) => {
+  test('toggling a tool window reflows in place, never remounting the well', async ({ page }) => {
+    // The black-frame-drop regression: the PanelGroup was keyed on the visible
+    // panel set, so opening or closing a tool window tore the whole well down
+    // and rebuilt it (a flash to the frame, then back). Tag the editor panel
+    // and prove the node survives the toggle: reconcile, not remount.
+    const editor = page.locator('[data-panel-id="region-editor"]');
+    await expect(editor).toBeVisible();
+    await editor.evaluate((el) => (el.dataset.remountProbe = 'kept'));
+    const widthOpen = await editor.evaluate((el) => Math.round(el.getBoundingClientRect().width));
+    // Close the thread window: the editor widens and the same node survives.
+    await page.keyboard.press('Alt+9');
+    await expect(page.locator('nav button[aria-label="Thread tool window"]')).toHaveAttribute(
+      'aria-pressed',
+      'false',
+    );
+    await expect(editor).toHaveAttribute('data-remount-probe', 'kept');
+    const widthClosed = await editor.evaluate((el) => Math.round(el.getBoundingClientRect().width));
+    expect(widthClosed).toBeGreaterThan(widthOpen);
+    // Reopen: the node is still the same one, and the arrangement returns.
+    await page.keyboard.press('Alt+9');
+    await expect(page.locator('nav button[aria-label="Thread tool window"]')).toHaveAttribute(
+      'aria-pressed',
+      'true',
+    );
+    await expect(editor).toHaveAttribute('data-remount-probe', 'kept');
+  });
+
+  test('surface rail round-trips surfaces with their own arrangements', async ({ page }) => {
     // Close the workspace's thread window so Workspace has a distinct shape.
     await page.keyboard.press('Alt+9');
     await expect(page.locator('nav button[aria-label="Thread tool window"]')).toHaveAttribute(
       'aria-pressed',
       'false',
     );
-    // Switch to Index from the toolbar widget.
-    await page.locator('[data-layout-switcher]').click();
-    await page.locator('[data-layout-option="console-index"]').click();
+    // Switch to Index from the leftmost stripe's surfaces group.
+    await page.locator('[data-surface-nav="console-index"]').click();
     await expect(page.locator('[data-shell]')).toHaveAttribute('data-active-surface', 'console-index');
     // The Index screen: destination rail naming its gap, live triage stream.
     await expect(page.getByText('destinations (connectors')).toBeVisible();
     await expect.poll(() => page.locator('tbody tr').count()).toBeGreaterThanOrEqual(12);
     // Documents: list left, Galley reading view center.
-    await page.locator('[data-layout-switcher]').click();
-    await page.locator('[data-layout-option="console-docs"]').click();
+    await page.locator('[data-surface-nav="console-docs"]').click();
     await expect(page.locator('[data-shell]')).toHaveAttribute('data-active-surface', 'console-docs');
     await expect(page.locator('[data-doc-id]').first()).toBeVisible();
     await expect(page.locator('.galley').first()).toBeVisible();
     // Back to Workspace: the closed thread window survived the round trip
     // and a reload (per-surface arrangement snapshots, R3.3).
-    await page.locator('[data-layout-switcher]').click();
-    await page.locator('[data-layout-option="console-workspace"]').click();
+    await page.locator('[data-surface-nav="console-workspace"]').click();
     await expect(page.locator('nav button[aria-label="Thread tool window"]')).toHaveAttribute(
       'aria-pressed',
       'false',
diff --git a/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-darwin.png b/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-darwin.png
index d91a87c1..ae5687a5 100644
Binary files a/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-darwin.png and b/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-darwin.png differ
diff --git a/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-linux.png b/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-linux.png
index 9ce3aa9e..cc706993 100644
Binary files a/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-linux.png and b/apps/console/e2e/omnibar.spec.ts-snapshots/omnibar-expanded-ask-linux.png differ
diff --git a/apps/console/e2e/proof-workspace.spec.ts b/apps/console/e2e/proof-workspace.spec.ts
index ac5ac5bf..6130d099 100644
--- a/apps/console/e2e/proof-workspace.spec.ts
+++ b/apps/console/e2e/proof-workspace.spec.ts
@@ -41,8 +41,11 @@ test.describe('proof workspace', () => {
     await expect(page.getByRole('tab', { name: 'surface-tree.ts' })).toBeVisible();
     // The brief reads through Galley inside the editor well.
     await expect(page.locator('.galley').first()).toBeVisible();
-    // The thread names its missing capability instead of faking activity.
-    await expect(page.getByText('NEXT_PUBLIC_CONSOLE_CHAT_URL')).toBeVisible();
+    // The chat wire is configured in e2e (the /do entry needs a live
+    // composer), so the thread renders its real composer; the named
+    // unavailable state for an unset NEXT_PUBLIC_CONSOLE_CHAT_URL lives in
+    // ThreadView and is exercised without the env in unit scope.
+    await expect(page.locator('[data-thread-composer-input]')).toBeVisible();
     // Entrance settled: chrome is fully opaque after the budget.
     const opacity = await page
       .locator('section[aria-label="Records tool window"]')
diff --git a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-darwin.png b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-darwin.png
index 82b4df6f..dbc15873 100644
Binary files a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-darwin.png and b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-darwin.png differ
diff --git a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-linux.png b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-linux.png
index 5c7887a4..b8448b9c 100644
Binary files a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-linux.png and b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1280-dark-linux.png differ
diff --git a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-darwin.png b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-darwin.png
index 83d3b2fc..d1c08ebf 100644
Binary files a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-darwin.png and b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-darwin.png differ
diff --git a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-linux.png b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-linux.png
index 7bcb43f2..bdf227e0 100644
Binary files a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-linux.png and b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-dark-linux.png differ
diff --git a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-darwin.png b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-darwin.png
index 77be2a6e..24bd2066 100644
Binary files a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-darwin.png and b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-darwin.png differ
diff --git a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-linux.png b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-linux.png
index c35c30a6..47219971 100644
Binary files a/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-linux.png and b/apps/console/e2e/proof-workspace.spec.ts-snapshots/workspace-1440-reduced-motion-linux.png differ
diff --git a/apps/console/e2e/stub-data-api.mjs b/apps/console/e2e/stub-data-api.mjs
index bd5c5547..c177c5d6 100644
--- a/apps/console/e2e/stub-data-api.mjs
+++ b/apps/console/e2e/stub-data-api.mjs
@@ -66,6 +66,138 @@ function seedRecords() {
 
 const RECORDS = seedRecords();
 
+// Domain fixtures for the card engine + mentions surface (K1/K2/K6
+// acceptance): a real person and task render through their templates against
+// this seam, relation chips resolve to these objects, and the mention
+// candidates drive the confirm/dismiss round trip. Types are the seam's
+// canonical dash form.
+const DOMAIN = [
+  {
+    id: 'org-braintrust',
+    type: 'org',
+    properties: { title: 'Braintrust', kind: 'org' },
+    relations: {},
+  },
+  {
+    id: 'project-porchfest',
+    type: 'project',
+    properties: { title: 'PorchFest 2026', kind: 'project', status: 'active' },
+    relations: {},
+  },
+  {
+    id: 'skill-rust',
+    type: 'skill',
+    properties: { title: 'Rust', kind: 'skill' },
+    relations: {},
+  },
+  {
+    id: 'person-ada',
+    type: 'person',
+    properties: {
+      title: 'Ada Lovelace',
+      kind: 'person',
+      role: 'Analyst',
+      email: 'ada@example.test',
+      location: 'London',
+      aliases: ['Countess of Lovelace'],
+    },
+    relations: {
+      WORKS_AT: ['org-braintrust'],
+      HAS_SKILL: ['skill-rust'],
+      IN_PROJECT: ['project-porchfest'],
+    },
+  },
+  {
+    id: 'task-report',
+    type: 'task',
+    properties: {
+      title: 'Send the compliance report',
+      kind: 'task',
+      status: 'open',
+      priority: 'high',
+      due: '2026-07-21',
+      progress: 40,
+    },
+    relations: { IN_PROJECT: ['project-porchfest'] },
+  },
+];
+
+const MENTION_CANDIDATES = [
+  {
+    id: 'mention:person-ada:rec-1:ada-lovelace',
+    type: 'mention-candidate',
+    properties: {
+      title: 'Ada Lovelace in rec-1',
+      object_id: 'person-ada',
+      atom_id: 'rec-1',
+      matched_alias: 'Ada Lovelace',
+      tier: 'exact',
+      status: 'unlinked',
+      snippet: 'Filed after the sync: Ada Lovelace flagged the setback distance.',
+      snippet_start: 22,
+      snippet_end: 34,
+    },
+    relations: {},
+  },
+  {
+    id: 'mention:person-ada:rec-2:countess-of-lovelace',
+    type: 'mention-candidate',
+    properties: {
+      title: 'Countess of Lovelace in rec-2',
+      object_id: 'person-ada',
+      atom_id: 'rec-2',
+      matched_alias: 'Countess of Lovelace',
+      tier: 'normalized',
+      status: 'unlinked',
+      snippet: 'The countess of lovelace annotated the memoir margins.',
+      snippet_start: 4,
+      snippet_end: 24,
+    },
+    relations: {},
+  },
+];
+
+// Documents and code files ride the live wire now (the file-editing fix), so
+// the stub serves them and applies edits in place, exercising the real
+// browser -> proxy -> upstream path for persisted document editing.
+const DOCS = [
+  {
+    id: 'doc-console-brief',
+    type: 'doc',
+    properties: {
+      slug: 'console-brief',
+      title: 'The harness console',
+      markdown:
+        '# The harness console\n\nImagine Cursor had forked IntelliJ instead of VS Code, with sidebars that show code and markdown as easily as they show data models.\n\n## The mechanism\n\nThe chrome outside is Int UI: tool window stripes down the edges, a sunken editor well, a main toolbar with a run widget, a status bar.\n',
+    },
+    relations: {},
+  },
+  {
+    id: 'doc-console-punch-list',
+    type: 'doc',
+    properties: {
+      slug: 'console-punch-list',
+      title: 'Console punch list',
+      markdown:
+        '# Console punch list\n\nWorking notes for the console itself. Each todo carries the action affordance.\n\n## Open items\n\n- [ ] Wire the destination rail to live connector counts\n- [ ] Capture a fresh visual baseline after the card engine lands\n- [x] Point the record table at the deployed object seam\n',
+    },
+    relations: {},
+  },
+];
+
+const CODE_FILES = [
+  {
+    id: 'code-surface-tree',
+    type: 'code-file',
+    properties: {
+      path: 'packages/block-view/src/surface-tree.ts',
+      language: 'typescript',
+      content: "export const CONTAINS_EDGE = 'CONTAINS';\n",
+    },
+    relations: {},
+  },
+];
+
 const HUNKS = [
   {
     id: 'hunk-agent-run',
@@ -128,6 +260,38 @@ const HUNKS = [
   },
 ];
 
+const POOLS = new Map([
+  ['record', RECORDS],
+  ['person', DOMAIN.filter((o) => o.type === 'person')],
+  ['task', DOMAIN.filter((o) => o.type === 'task')],
+  ['org', DOMAIN.filter((o) => o.type === 'org')],
+  ['project', DOMAIN.filter((o) => o.type === 'project')],
+  ['skill', DOMAIN.filter((o) => o.type === 'skill')],
+  ['mention-candidate', MENTION_CANDIDATES],
+  ['doc', DOCS],
+  ['code-file', CODE_FILES],
+  ['hunk', HUNKS],
+]);
+
+/** Every stored object across pools, for id-keyed update. */
+function allStored() {
+  return [...POOLS.values()].flat();
+}
+
+function poolFor(types) {
+  const requested = Array.isArray(types) && types.length > 0 ? types : ['record'];
+  const objects = [];
+  const seen = new Set();
+  for (const type of requested) {
+    for (const object of POOLS.get(type) ?? []) {
+      if (!seen.has(object.id)) {
+        seen.add(object.id);
+        objects.push(object);
+      }
+    }
+  }
+  return objects;
+}
 function matches(object, predicate) {
   if (!predicate) return true;
   switch (predicate.kind) {
@@ -149,8 +313,7 @@ function matches(object, predicate) {
 }
 
 function runQuery(query) {
-  const pool = query.types?.includes('hunk') ? HUNKS : RECORDS;
-  let objects = pool.filter((object) => matches(object, query.where));
+  let objects = poolFor(query.types).filter((object) => matches(object, query.where));
   const ranker = query.rank?.[0];
   if (ranker?.kind === 'field') {
     const direction = ranker.direction === 'desc' ? -1 : 1;
@@ -202,6 +365,32 @@ const server = createServer((request, response) => {
       try {
         if (request.url === '/objects/action') {
           const action = JSON.parse(body);
+          // Update applies in place across every pool (mention confirm/dismiss
+          // K6, and persisted document/code edits): the surface's refetch sees
+          // the transition.
+          if (action.kind === 'update') {
+            const target = allStored().find((entry) => entry.id === action.id);
+            if (target) {
+              target.properties = { ...target.properties, ...action.patch };
+              response.writeHead(200, { 'Content-Type': 'application/json' });
+              response.end(
+                JSON.stringify({ action_kind: 'update', status: 'applied', target_ids: [action.id] }),
+              );
+              return;
+            }
+          }
+          // Create appends to the type's pool (the seed-content path); ids are
+          // deterministic for stable captures.
+          if (action.kind === 'create' && POOLS.has(action.type)) {
+            const pool = POOLS.get(action.type);
+            const id = `${action.type}-${pool.length + 1}`;
+            pool.push({ id, type: action.type, properties: { ...action.props }, relations: {} });
+            response.writeHead(200, { 'Content-Type': 'application/json' });
+            response.end(
+              JSON.stringify({ action_kind: 'create', status: 'applied', target_ids: [id] }),
+            );
+            return;
+          }
           response.writeHead(200, { 'Content-Type': 'application/json' });
           response.end(JSON.stringify({ action_kind: action.kind, status: 'accepted' }));
           return;
diff --git a/apps/console/playwright.config.ts b/apps/console/playwright.config.ts
index 14ec6f89..cd2c5258 100644
--- a/apps/console/playwright.config.ts
+++ b/apps/console/playwright.config.ts
@@ -37,6 +37,9 @@ export default defineConfig({
       env: {
         CONSOLE_DATA_API_URL: 'http://localhost:50591',
         CONSOLE_DATA_API_KEY: 'dev-key',
+        // The composer must be live for the /do entry (K3); the sheet's
+        // interception happens before any network send.
+        NEXT_PUBLIC_CONSOLE_CHAT_URL: '/api/chat/stream',
       },
     },
   ],
diff --git a/apps/console/src/app/api/harness/delegate/route.ts b/apps/console/src/app/api/harness/delegate/route.ts
new file mode 100644
index 00000000..9390a19e
--- /dev/null
+++ b/apps/console/src/app/api/harness/delegate/route.ts
@@ -0,0 +1,41 @@
+// SOURCING: none. Thin passthrough (K4): For me submits through the harness
+// delegate path (handoff plus job with the pack; the room appears in the
+// strip). Same env contract as presence/runs: unconfigured returns 404 and
+// the sheet renders its named unavailable state; an upstream refusal (the
+// identity refusal observable in production) passes its status through so the
+// sheet can name it. No fixture rooms ever render.
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: Request): Promise<Response> {
+  const base = process.env.CONSOLE_HARNESS_URL;
+  if (!base) {
+    return Response.json({ error: 'console_harness_unconfigured' }, { status: 404 });
+  }
+  const tenant = process.env.CONSOLE_HARNESS_TENANT ?? 'Travis-Gilbert';
+  const room = process.env.CONSOLE_HARNESS_ROOM ?? 'commonplace';
+  const pack = await req.text();
+  try {
+    const upstream = await fetch(
+      `${base.replace(/\/$/, '')}/harness/rooms/${encodeURIComponent(room)}/handoffs?tenant=${encodeURIComponent(tenant)}`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(process.env.CONSOLE_HARNESS_TOKEN
+            ? { Authorization: `Bearer ${process.env.CONSOLE_HARNESS_TOKEN}` }
+            : {}),
+        },
+        body: pack,
+        cache: 'no-store',
+      },
+    );
+    const body = await upstream.text();
+    return new Response(body, {
+      status: upstream.status,
+      headers: { 'Content-Type': upstream.headers.get('Content-Type') ?? 'application/json' },
+    });
+  } catch {
+    return Response.json({ error: 'harness_unreachable' }, { status: 502 });
+  }
+}
diff --git a/apps/console/src/components/ConsoleApp.tsx b/apps/console/src/components/ConsoleApp.tsx
index 361f38e1..8aca2a75 100644
--- a/apps/console/src/components/ConsoleApp.tsx
+++ b/apps/console/src/components/ConsoleApp.tsx
@@ -48,7 +48,17 @@ function RuntimeBoundary({ children }: { children: React.ReactNode }) {
     convertMessage,
     onNew: async (message: AppendMessage) => {
       const text = appendedText(message);
-      if (text) await send(text);
+      if (!text) return;
+      // The /do entry (K3): the composer's slash command opens the action
+      // sheet with the instruction pre-filled instead of sending a message.
+      if (/^\/do\b/i.test(text)) {
+        useShellStore.getState().openActionSheet({
+          instruction: text.replace(/^\/do\b/i, '').trim(),
+          chips: [],
+        });
+        return;
+      }
+      await send(text);
     },
     onCancel: async () => cancel(),
   });
@@ -96,6 +106,9 @@ export function ConsoleApp() {
     // Transport health is real: the object-seam probe sets the connection
     // state, and presence renders only when the harness transport reports it.
     void host.probe();
+    // Seed the backend's document fixtures once so the Documents surface has
+    // editable, persistent content (the file-editing wire).
+    void host.ensureSeedContent();
     let active = true;
     void fetch('/api/harness/presence', { cache: 'no-store' })
       .then(async (response) => {
diff --git a/apps/console/src/components/shell/ActionSheet.tsx b/apps/console/src/components/shell/ActionSheet.tsx
new file mode 100644
index 00000000..6d4a4dd1
--- /dev/null
+++ b/apps/console/src/components/shell/ActionSheet.tsx
@@ -0,0 +1,304 @@
+'use client';
+
+// SOURCING: motion (motion/react; the sheet entrance is an inventory row) +
+// zustand stores (shell + thread; With me stages visible refs into the
+// thread). The action sheet (HANDOFF-CARDS-ACTIONS-MENTIONS K3/K4): instruction plus
+// staged context, and context is never silent. All three entries (/do in the
+// composer, the todo-block action icon, the Action verb on inspector and
+// cards) open this same sheet. Staged chips show exactly what travels;
+// auto-suggest adds visible removable chips through a real title query (the
+// exact tier of the salience machinery reachable from the console today);
+// the submitted pack equals the visible chip set exactly.
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { motion } from 'motion/react';
+import type { BlockHost } from '@commonplace/block-view/types';
+import {
+  useShellStore,
+  type StagedContextChip,
+} from '@/lib/shell-store';
+import { useThreadStore } from '@/lib/thread-store';
+import {
+  buildActionPack,
+  packEqualsChips,
+  type ActionDestination,
+  type ActionFollowUp,
+} from '@/lib/action-pack';
+import { DUR, EASE_OUT, seconds, useMotionDurations } from '@/motion/motion-tokens';
+
+type SubmitState =
+  | { readonly kind: 'idle' }
+  | { readonly kind: 'submitting' }
+  | { readonly kind: 'refused'; readonly message: string }
+  | { readonly kind: 'done'; readonly message: string };
+
+export function ActionSheet({ host }: { host: BlockHost }) {
+  const origin = useShellStore((state) => state.actionSheetOrigin);
+  const close = useShellStore((state) => state.closeActionSheet);
+  if (!origin) return null;
+  return <ActionSheetOpen key={origin.chips[0]?.id ?? 'blank'} host={host} onClose={close} />;
+}
+
+function ActionSheetOpen({ host, onClose }: { host: BlockHost; onClose: () => void }) {
+  const origin = useShellStore((state) => state.actionSheetOrigin);
+  const stageInThread = useThreadStore((state) => state.stage);
+  const durations = useMotionDurations();
+  const [instruction, setInstruction] = useState(origin?.instruction ?? '');
+  const [chips, setChips] = useState<readonly StagedContextChip[]>(origin?.chips ?? []);
+  const [destination, setDestination] = useState<ActionDestination>('for-me');
+  const [followUp, setFollowUp] = useState<ActionFollowUp>('keep-open');
+  const [submit, setSubmit] = useState<SubmitState>({ kind: 'idle' });
+  const [suggesting, setSuggesting] = useState(false);
+  const fieldRef = useRef<HTMLTextAreaElement | null>(null);
+  const prevFocus = useRef<HTMLElement | null>(null);
+
+  useEffect(() => {
+    prevFocus.current = document.activeElement as HTMLElement | null;
+    fieldRef.current?.focus();
+    return () => prevFocus.current?.focus();
+  }, []);
+
+  const removeChip = useCallback((id: string) => {
+    setChips((current) => current.filter((chip) => chip.id !== id));
+  }, []);
+
+  /** Auto-suggest (named choice 4): candidates come from a real title query
+   *  against the seam (the exact tier reachable from the console; the full
+   *  salience machinery is the harness's). Every added chip is visible and
+   *  removable; nothing submits unseen. */
+  const suggest = useCallback(async () => {
+    const probe = instruction.trim().split(/\s+/).filter((word) => word.length > 3)[0];
+    if (!probe) return;
+    setSuggesting(true);
+    try {
+      const set = await host.query({
+        types: ['record', 'person', 'task', 'project', 'org'],
+        where: { kind: 'contains', field: 'title', value: probe },
+        page: { limit: 5 },
+      });
+      setChips((current) => {
+        const seen = new Set(current.map((chip) => chip.objectId));
+        const added = set.objects
+          .filter((object) => !seen.has(object.id))
+          .slice(0, 3)
+          .map(
+            (object): StagedContextChip => ({
+              id: `chip-auto-${object.id}`,
+              kind: 'object',
+              label: String(object.properties.title ?? object.id),
+              objectId: object.id,
+              objectType: object.type,
+              source: 'auto',
+            }),
+          );
+        return [...current, ...added];
+      });
+    } catch {
+      // No candidates reachable: the chip list simply does not grow.
+    } finally {
+      setSuggesting(false);
+    }
+  }, [host, instruction]);
+
+  const submitSheet = useCallback(async () => {
+    const pack = buildActionPack(instruction, chips, destination, followUp);
+    // The named invariant of the round: the pack equals the visible chips.
+    if (!packEqualsChips(pack, chips)) {
+      setSubmit({ kind: 'refused', message: 'pack drifted from the visible chips; not submitting' });
+      return;
+    }
+    if (destination === 'with-me') {
+      // With me stays console-local (K4): chips become visible object
+      // references staged above the thread composer, and focus moves there.
+      stageInThread(
+        chips.map((chip) => ({
+          id: chip.id,
+          label: chip.label,
+          objectId: chip.objectId,
+        })),
+      );
+      onClose();
+      requestAnimationFrame(() => {
+        document
+          .querySelector<HTMLTextAreaElement>('[data-thread-composer-input]')
+          ?.focus();
+      });
+      return;
+    }
+    setSubmit({ kind: 'submitting' });
+    try {
+      const response = await fetch('/api/harness/delegate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(pack),
+      });
+      if (response.ok) {
+        setSubmit({ kind: 'done', message: 'handed off: the room appears in the strip' });
+        return;
+      }
+      const message =
+        response.status === 404
+          ? 'the harness delegate wire is not configured (CONSOLE_HARNESS_URL)'
+          : response.status === 401 || response.status === 403
+            ? 'the harness refused this identity; With me still works'
+            : `the harness declined the handoff (${response.status})`;
+      setSubmit({ kind: 'refused', message });
+    } catch {
+      setSubmit({ kind: 'refused', message: 'the harness is unreachable; With me still works' });
+    }
+  }, [instruction, chips, destination, followUp, stageInThread, onClose]);
+
+  return (
+    <div
+      className="absolute inset-0 z-40 flex items-start justify-center"
+      role="presentation"
+      onMouseDown={(event) => {
+        if (event.target === event.currentTarget) onClose();
+      }}
+      onKeyDown={(event) => {
+        if (event.key === 'Escape') {
+          event.stopPropagation();
+          onClose();
+        }
+      }}
+    >
+      <motion.div
+        role="dialog"
+        aria-modal="true"
+        aria-label="Action sheet"
+        data-action-sheet
+        initial={durations.reduced ? { opacity: 0 } : { opacity: 0, scale: 0.98 }}
+        animate={{ opacity: 1, scale: 1 }}
+        transition={{
+          // Reduced motion renders the sheet without the material animation
+          // (K3 acceptance): a plain fade, no scale.
+          duration: seconds(durations.reduced ? DUR.fast : durations.fast),
+          ease: EASE_OUT,
+        }}
+        className="mt-24 w-full max-w-xl overflow-hidden rounded-ij-arc border border-ij-seam-raised bg-ij-raised"
+      >
+        <div className="border-b border-ij-divider p-3">
+          <textarea
+            ref={fieldRef}
+            rows={2}
+            value={instruction}
+            onChange={(event) => setInstruction(event.target.value)}
+            onKeyDown={(event) => {
+              if (event.key === 'Enter' && (event.metaKey || event.ctrlKey)) {
+                event.preventDefault();
+                void submitSheet();
+              }
+            }}
+            placeholder="What should the agent do?"
+            aria-label="Instruction"
+            className="w-full resize-none rounded-ij-arc border border-ij-control-border bg-ij-editor px-3 py-1 text-ij-ink placeholder:text-ij-ink-disabled focus:outline-2 focus:outline-ij-accent"
+          />
+        </div>
+
+        <div className="flex flex-wrap items-center gap-1 border-b border-ij-divider p-3" data-staged-context>
+          {chips.map((chip) => (
+            <span
+              key={chip.id}
+              data-context-chip={chip.source}
+              className="inline-flex h-6 items-center gap-1 rounded-ij-arc border border-ij-control-border bg-ij-editor px-2 text-ij-ink"
+            >
+              <span className="text-ij-ink-info">{chip.kind}</span>
+              <span className="max-w-48 truncate">{chip.label}</span>
+              <button
+                type="button"
+                aria-label={`Remove ${chip.label}`}
+                onClick={() => removeChip(chip.id)}
+                className="text-ij-ink-info hover:text-ij-ink focus:outline-2 focus:outline-ij-accent"
+              >
+                ×
+              </button>
+            </span>
+          ))}
+          <button
+            type="button"
+            onClick={() => void suggest()}
+            disabled={suggesting}
+            data-auto-suggest
+            className="inline-flex h-6 items-center rounded-ij-arc px-2 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink focus:outline-2 focus:outline-ij-accent"
+            style={{ transition: 'var(--rec-clickable-transition)' }}
+          >
+            {suggesting ? 'Suggesting…' : '+ Suggest context'}
+          </button>
+        </div>
+
+        <div className="flex flex-wrap items-center gap-3 border-b border-ij-divider p-3">
+          <div role="radiogroup" aria-label="Destination" className="flex overflow-hidden rounded-ij-arc border border-ij-control-border">
+            {(
+              [
+                ['for-me', 'For me'],
+                ['with-me', 'With me'],
+              ] as const
+            ).map(([value, label]) => (
+              <button
+                key={value}
+                type="button"
+                role="radio"
+                aria-checked={destination === value}
+                onClick={() => setDestination(value)}
+                data-destination={value}
+                className={
+                  destination === value
+                    ? 'h-ij-control bg-ij-selection px-3 text-ij-ink'
+                    : 'h-ij-control bg-ij-editor px-3 text-ij-ink-info hover:bg-ij-hover-surface'
+                }
+                style={{ transition: 'var(--rec-clickable-transition)' }}
+              >
+                {label}
+              </button>
+            ))}
+          </div>
+          <label className="flex items-center gap-1 text-ij-ink-info">
+            <input
+              type="checkbox"
+              checked={followUp === 'mark-handled'}
+              onChange={(event) => setFollowUp(event.target.checked ? 'mark-handled' : 'keep-open')}
+            />
+            Mark handled after
+          </label>
+          <span
+            className="text-ij-ink-disabled"
+            title="Saving as a rule needs the rules engine (IX6), which is not built yet."
+            data-save-as-rule-unavailable
+          >
+            Save as rule (needs IX6)
+          </span>
+        </div>
+
+        <div className="flex items-center gap-2 p-3">
+          <button
+            type="button"
+            onClick={() => void submitSheet()}
+            disabled={submit.kind === 'submitting' || !instruction.trim()}
+            className="h-ij-control rounded-ij-arc bg-ij-accent px-4 text-ij-ink-bright hover:bg-ij-accent-hover focus:outline-2 focus:outline-ij-accent disabled:opacity-50"
+            style={{ transition: 'var(--rec-clickable-transition)' }}
+          >
+            {destination === 'for-me' ? 'Hand off' : 'Stage in thread'}
+          </button>
+          <button
+            type="button"
+            onClick={onClose}
+            className="h-ij-control rounded-ij-arc px-3 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink"
+            style={{ transition: 'var(--rec-clickable-transition)' }}
+          >
+            Cancel
+          </button>
+          {submit.kind === 'refused' ? (
+            <span data-delegate-refused className="text-ij-error">
+              {submit.message}
+            </span>
+          ) : null}
+          {submit.kind === 'done' ? (
+            <span data-delegate-done className="text-ij-ink-info">
+              {submit.message}
+            </span>
+          ) : null}
+        </div>
+      </motion.div>
+    </div>
+  );
+}
diff --git a/apps/console/src/components/shell/IntuiShell.tsx b/apps/console/src/components/shell/IntuiShell.tsx
index 630fe149..eebdcd74 100644
--- a/apps/console/src/components/shell/IntuiShell.tsx
+++ b/apps/console/src/components/shell/IntuiShell.tsx
@@ -27,11 +27,32 @@ import { EditorTabs } from './EditorTabs';
 import { MainToolbar } from './MainToolbar';
 import { StatusBar } from './StatusBar';
 import { OmnibarIsland } from './Omnibar';
+import { ActionSheet } from './ActionSheet';
 import { RecordInspector } from '@/views/RecordInspector';
-import { IconDoc, IconRail, IconRecords, IconThread } from './icons';
+import {
+  IconCards,
+  IconDoc,
+  IconInspector,
+  IconModel,
+  IconRail,
+  IconRecords,
+  IconThread,
+  IconWorkspace,
+} from './icons';
 
 const OVERLAY_BREAKPOINT = 1100;
 
+/** Surface nav icons by surface kind: the stripe surfaces group (AMENDMENT:
+ *  surfaces join the layout switcher AND the stripe surfaces group). */
+const SURFACE_ICONS: Record<string, typeof IconRecords> = {
+  workspace: IconWorkspace,
+  index: IconRail,
+  documents: IconDoc,
+  cards: IconCards,
+  model: IconModel,
+  review: IconInspector,
+};
+
 /** Region icon slugs carried on the surface object; the glyphs stay in the
  *  one chrome icon file. */
 const REGION_ICONS: Record<string, typeof IconRecords> = {
@@ -123,6 +144,70 @@ function StripeButton({
   );
 }
 
+/** The stripe surfaces group: the top group of the leftmost stripe lists every
+ *  seeded surface and switches screens by flipping the active flag through the
+ *  host. This is the primary navigation (the AMENDMENT's stripe surfaces
+ *  group); it shares the leftmost bar with the active surface's tool windows,
+ *  divided, in the JetBrains grouped-stripe manner. */
+function SurfaceNavGroup({
+  surfaces,
+  activeSurfaceId,
+  host,
+}: {
+  surfaces: readonly ObjectRef[];
+  activeSurfaceId: string;
+  host: ConsoleBlockHost;
+}) {
+  const durations = useMotionDurations();
+  if (surfaces.length === 0) return null;
+  const switchTo = (surfaceId: string) => {
+    if (surfaceId === activeSurfaceId) return;
+    for (const surface of surfaces) {
+      void host.emit({
+        kind: 'update',
+        id: surface.id,
+        patch: { active: surface.id === surfaceId },
+      });
+    }
+  };
+  return (
+    <div data-surface-rail className="flex flex-col items-center gap-1">
+      {surfaces.map((surface, index) => {
+        const kind = String(surface.properties.kind ?? '');
+        const name = String(surface.properties.name ?? surface.id);
+        const Icon = SURFACE_ICONS[kind] ?? IconWorkspace;
+        const active = surface.id === activeSurfaceId;
+        return (
+          <motion.button
+            key={surface.id}
+            initial={durations.reduced ? false : { opacity: 0, y: 4 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{
+              duration: seconds(durations.base),
+              delay: seconds(staggerDelay(index)),
+              ease: EASE_OUT,
+            }}
+            type="button"
+            data-surface-nav={surface.id}
+            title={name}
+            aria-label={`${name} surface`}
+            aria-current={active ? 'page' : undefined}
+            onClick={() => switchTo(surface.id)}
+            className="flex h-10 w-10 items-center justify-center rounded-ij-arc"
+            style={{
+              color: active ? 'var(--ij-ink-bright)' : 'var(--ij-ink-info)',
+              background: active ? 'var(--ij-accent)' : 'transparent',
+              transition: 'var(--rec-clickable-transition)',
+            }}
+          >
+            <Icon size={16} />
+          </motion.button>
+        );
+      })}
+    </div>
+  );
+}
+
 /** The thread header carries the mark (R4.2: header and composer line are the
  *  mark's only placements); state binds to the one ambient runtime. */
 function HeaderMark() {
@@ -322,14 +407,42 @@ export function IntuiShell({ host }: { host: ConsoleBlockHost }) {
     </motion.div>
   );
 
-  const groupKey = `${activeSurfaceId}:${visiblePanels.map((panel) => panel.region.object.id).join('+')}`;
+  // The PanelGroup remounts ONLY when the active surface changes (a real
+  // screen switch), never when a tool window toggles. Keying on the visible
+  // panel set instead tore the whole well down and rebuilt it on every
+  // open/close, which read as a black frame drop (the editor and thread
+  // unmounted, and the editor's delayed entrance fade re-fired) rather than
+  // a smooth reflow. react-resizable-panels reconciles a panel appearing or
+  // disappearing in place, given each panel a stable id and order.
+  const groupKey = activeSurfaceId;
+
+  // Stable panel order from the full region lists (open or closed), so adding
+  // or removing a visible panel never renumbers the others: left windows
+  // first, then the editor, then right windows.
+  const orderOf = (region: RegionNode): number => {
+    const leftIndex = regions.left.indexOf(region);
+    if (leftIndex >= 0) return leftIndex + 1;
+    if (region === regions.editor) return regions.left.length + 1;
+    const rightIndex = regions.right.indexOf(region);
+    if (rightIndex >= 0) return regions.left.length + 2 + rightIndex;
+    return 999;
+  };
 
   return (
     <div ref={shellRef} data-shell data-active-surface={activeSurfaceId} className="relative flex h-full min-h-0 flex-col bg-ij-frame">
       <MainToolbar host={host} surfaces={(layoutObjects ?? []).filter((object) => object.type === 'surface')} activeSurfaceId={activeSurfaceId} />
       <div className="flex min-h-0 flex-1">
-        {/* Left stripe */}
-        <nav aria-label="Left tool window stripe" className="flex w-ij-stripe shrink-0 flex-col items-center gap-1 border-r border-ij-seam bg-ij-chrome py-1">
+        {/* The leftmost stripe: screen navigation (surfaces group) on top,
+            then the active surface's tool windows, divided. One bar. */}
+        <nav aria-label="Screens and tool windows" className="flex w-ij-stripe shrink-0 flex-col items-center gap-1 border-r border-ij-seam bg-ij-chrome py-1">
+          <SurfaceNavGroup
+            surfaces={(layoutObjects ?? []).filter((object) => object.type === 'surface')}
+            activeSurfaceId={activeSurfaceId}
+            host={host}
+          />
+          {regions.left.length > 0 ? (
+            <div aria-hidden className="my-1 h-px w-6 shrink-0 bg-ij-seam" />
+          ) : null}
           {regions.left.map((region, index) => (
             <StripeButton
               key={region.object.id}
@@ -374,7 +487,7 @@ export function IntuiShell({ host }: { host: ConsoleBlockHost }) {
                   <Panel
                     key={panel.region.object.id}
                     id={panel.region.object.id}
-                    order={index + 1}
+                    order={orderOf(panel.region)}
                     defaultSize={(panel.abs / visibleTotal) * 100}
                     minSize={isEditor ? 30 : 14}
                   >
@@ -416,6 +529,7 @@ export function IntuiShell({ host }: { host: ConsoleBlockHost }) {
       </div>
       <StatusBar host={host} />
       <OmnibarIsland host={host} />
+      <ActionSheet host={host} />
     </div>
   );
 }
diff --git a/apps/console/src/components/shell/MainToolbar.tsx b/apps/console/src/components/shell/MainToolbar.tsx
index 53bea2c9..b30f85a9 100644
--- a/apps/console/src/components/shell/MainToolbar.tsx
+++ b/apps/console/src/components/shell/MainToolbar.tsx
@@ -1,20 +1,19 @@
 'use client';
 
 // SOURCING: hand-roll. The Int UI main toolbar with the RunWidget is a named
-// chrome signature; no library models it. The project widget is the layout
-// switcher (R3.3): it lists the seeded surface objects and switches screens
-// by flipping the active flag through the host; the widget is chrome and
-// renders in Int UI type. The toolbar center hosts the omnibar's collapsed
-// field (R1); while a run streams, the field gives way to the quiet
-// streaming chip carrying the mark at chip scale. The run widget binds to
-// real run state and renders its empty state otherwise, never a fixture run.
+// chrome signature; no library models it. Screen navigation lives in the
+// leftmost stripe (the stripe surfaces group), not a toolbar dropdown; the
+// toolbar shows the product name and the active screen as a quiet breadcrumb.
+// The toolbar center hosts the omnibar's collapsed field (R1); while a run
+// streams, the field gives way to the quiet streaming chip carrying the mark
+// at chip scale. The run widget binds to real run state and renders its empty
+// state otherwise, never a fixture run.
 
-import { useEffect, useRef, useState } from 'react';
 import type { BlockHost, ObjectRef } from '@commonplace/block-view/types';
 import { useShellStore } from '@/lib/shell-store';
 import { useThreadStore } from '@/lib/thread-store';
 import { OmnibarField } from './Omnibar';
-import { IconChevronDown, IconRun, IconSearch, IconStop } from './icons';
+import { IconRun, IconSearch, IconStop } from './icons';
 
 interface MainToolbarProps {
   readonly host: BlockHost;
@@ -22,87 +21,25 @@ interface MainToolbarProps {
   readonly activeSurfaceId: string;
 }
 
-function LayoutSwitcher({ host, surfaces, activeSurfaceId }: MainToolbarProps) {
-  const [open, setOpen] = useState(false);
-  const rootRef = useRef<HTMLDivElement | null>(null);
-  const active = surfaces.find((surface) => surface.id === activeSurfaceId);
-  const label = String(active?.properties.name ?? 'Workspace');
-
-  useEffect(() => {
-    if (!open) return;
-    const onPointerDown = (event: PointerEvent) => {
-      if (rootRef.current && !rootRef.current.contains(event.target as Node)) setOpen(false);
-    };
-    window.addEventListener('pointerdown', onPointerDown);
-    return () => window.removeEventListener('pointerdown', onPointerDown);
-  }, [open]);
-
-  const switchTo = (surfaceId: string) => {
-    for (const surface of surfaces) {
-      void host.emit({
-        kind: 'update',
-        id: surface.id,
-        patch: { active: surface.id === surfaceId },
-      });
-    }
-    setOpen(false);
-  };
-
-  return (
-    <div ref={rootRef} className="relative">
-      <button
-        type="button"
-        data-layout-switcher
-        aria-haspopup="listbox"
-        aria-expanded={open}
-        aria-label={`Layout: ${label}`}
-        onClick={() => setOpen((current) => !current)}
-        className="flex h-ij-control items-center gap-1 rounded-ij-arc px-2 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink"
-        style={{ transition: 'var(--rec-clickable-transition)' }}
-      >
-        {label}
-        <IconChevronDown size={12} />
-      </button>
-      {open ? (
-        <div
-          role="listbox"
-          aria-label="Layouts"
-          className="absolute left-0 top-full z-50 mt-1 min-w-40 overflow-hidden rounded-ij-arc border border-ij-seam-raised bg-ij-raised p-1"
-        >
-          {surfaces.map((surface) => {
-            const selected = surface.id === activeSurfaceId;
-            return (
-              <button
-                key={surface.id}
-                type="button"
-                role="option"
-                aria-selected={selected}
-                data-layout-option={surface.id}
-                onClick={() => switchTo(surface.id)}
-                className="flex h-ij-row w-full items-center rounded-ij-arc-underline px-2 text-left text-ij-ink aria-selected:bg-ij-selection"
-                style={{ transition: 'var(--rec-clickable-transition)' }}
-              >
-                {String(surface.properties.name ?? surface.id)}
-              </button>
-            );
-          })}
-        </div>
-      ) : null}
-    </div>
-  );
-}
-
-export function MainToolbar({ host, surfaces, activeSurfaceId }: MainToolbarProps) {
+export function MainToolbar({ surfaces, activeSurfaceId }: MainToolbarProps) {
   const isRunning = useThreadStore((state) => state.isRunning);
   const cancel = useThreadStore((state) => state.cancel);
   const openOmnibar = useShellStore((state) => state.openOmnibar);
+  const activeName = String(
+    surfaces.find((surface) => surface.id === activeSurfaceId)?.properties.name ?? 'Workspace',
+  );
 
   return (
     <header className="flex h-ij-toolbar shrink-0 items-center gap-2 border-b border-ij-seam bg-ij-chrome px-2">
       <span className="px-2 text-ij-ink" style={{ fontWeight: 'var(--rec-weight-cap)' }}>
         CommonPlace
       </span>
-      <LayoutSwitcher host={host} surfaces={surfaces} activeSurfaceId={activeSurfaceId} />
+      <span aria-hidden className="text-ij-ink-disabled">
+        /
+      </span>
+      <span data-active-surface-name className="text-ij-ink-info">
+        {activeName}
+      </span>
 
       <div className="mx-2 min-w-0 flex-1">
         <div className="mx-auto max-w-144">
diff --git a/apps/console/src/components/shell/Omnibar.tsx b/apps/console/src/components/shell/Omnibar.tsx
index e0dd8f4e..4cbd8042 100644
--- a/apps/console/src/components/shell/Omnibar.tsx
+++ b/apps/console/src/components/shell/Omnibar.tsx
@@ -127,7 +127,12 @@ export function OmnibarIsland({ host }: { host: BlockHost }) {
     if (target && document.contains(target)) target.focus();
   }, [closeOmnibar]);
 
-  // Global keys: double Shift opens Search; Ctrl or Cmd L/K opens Ask.
+  // Global keys: double Shift opens Search; Ctrl or Cmd L opens Ask (the
+  // Cursor muscle-memory key from named choice 3, live in the desktop shell),
+  // and Ctrl or Cmd K opens Ask too. The desktop key is browser-reserved for
+  // the address bar, so a browser tab never delivers it to the page; K is the
+  // command-palette convention browsers do deliver, so the keyboard path
+  // works in both targets.
   useEffect(() => {
     const onKeyDown = (event: KeyboardEvent) => {
       const askKey = event.key === 'l' || event.key === 'L' || event.key === 'k' || event.key === 'K';
diff --git a/apps/console/src/components/shell/icons.tsx b/apps/console/src/components/shell/icons.tsx
index d44ff653..d90282f6 100644
--- a/apps/console/src/components/shell/icons.tsx
+++ b/apps/console/src/components/shell/icons.tsx
@@ -99,11 +99,35 @@ export function IconDoc(props: IconProps) {
   );
 }
 
-/** Layout switcher chevron for the toolbar project widget. */
-export function IconChevronDown(props: IconProps) {
+/** Surface nav: workspace (split panes). */
+export function IconWorkspace(props: IconProps) {
   return (
     <svg {...base(props)}>
-      <path d="m4.5 6.5 3.5 3.5 3.5-3.5" />
+      <rect x="2" y="3" width="12" height="10" rx="1.5" />
+      <path d="M6.5 3v10" />
+    </svg>
+  );
+}
+
+/** Surface nav: cards (stacked faces). */
+export function IconCards(props: IconProps) {
+  return (
+    <svg {...base(props)}>
+      <rect x="3" y="4.5" width="9" height="8" rx="1.5" />
+      <path d="M5 4.5V3.5A1 1 0 0 1 6 2.5h6a1 1 0 0 1 1 1v7" />
     </svg>
   );
 }
+
+/** Surface nav: model (kinds and relations). */
+export function IconModel(props: IconProps) {
+  return (
+    <svg {...base(props)}>
+      <circle cx="4" cy="4" r="1.75" />
+      <circle cx="12" cy="12" r="1.75" />
+      <circle cx="12" cy="4" r="1.75" />
+      <path d="M5.2 5.2 10.8 10.8M5.75 4h4.5" />
+    </svg>
+  );
+}
+
diff --git a/apps/console/src/lib/action-pack.test.ts b/apps/console/src/lib/action-pack.test.ts
new file mode 100644
index 00000000..449e8b9e
--- /dev/null
+++ b/apps/console/src/lib/action-pack.test.ts
@@ -0,0 +1,51 @@
+// K7 (HANDOFF-CARDS-ACTIONS-MENTIONS): the pack serialization contract test.
+// The pack-equals-chips assertion is the named invariant test of the round:
+// the submitted pack is exactly the visible chip set, originating object
+// first, nothing added, nothing dropped.
+
+import { describe, expect, it } from 'vitest';
+import { buildActionPack, packEqualsChips } from './action-pack';
+import { objectChip, type StagedContextChip } from './shell-store';
+
+const ORIGIN = objectChip('rec-1', 'task', 'Send the report');
+const MANUAL: StagedContextChip = {
+  id: 'chip-manual-1',
+  kind: 'selection',
+  label: 'the failing paragraph',
+  text: 'the failing paragraph',
+  source: 'manual',
+};
+const AUTO: StagedContextChip = {
+  id: 'chip-auto-rec-2',
+  kind: 'object',
+  label: 'Weekly compliance sync',
+  objectId: 'rec-2',
+  objectType: 'record',
+  source: 'auto',
+};
+
+describe('the prepared pack', () => {
+  it('serializes exactly the visible chips, origin first', () => {
+    const pack = buildActionPack('send it', [MANUAL, ORIGIN, AUTO], 'for-me', 'keep-open');
+    expect(pack.context).toHaveLength(3);
+    expect(pack.context[0]).toMatchObject({ kind: 'object', object_id: 'rec-1' });
+    expect(packEqualsChips(pack, [MANUAL, ORIGIN, AUTO])).toBe(true);
+  });
+
+  it('detects a pack that drifted from the chips', () => {
+    const pack = buildActionPack('send it', [ORIGIN, AUTO], 'for-me', 'keep-open');
+    expect(packEqualsChips(pack, [ORIGIN, AUTO, MANUAL])).toBe(false);
+    expect(packEqualsChips(pack, [ORIGIN])).toBe(false);
+  });
+
+  it('a removed auto chip never reaches the pack', () => {
+    const visible = [ORIGIN, MANUAL];
+    const pack = buildActionPack('send it', visible, 'with-me', 'mark-handled');
+    expect(pack.context.map((entry) => entry.label)).toEqual([
+      'Send the report',
+      'the failing paragraph',
+    ]);
+    expect(pack.destination).toBe('with-me');
+    expect(pack.follow_up).toBe('mark-handled');
+  });
+});
diff --git a/apps/console/src/lib/action-pack.ts b/apps/console/src/lib/action-pack.ts
new file mode 100644
index 00000000..8034a6ea
--- /dev/null
+++ b/apps/console/src/lib/action-pack.ts
@@ -0,0 +1,72 @@
+// SOURCING: none. Pure logic, no upstream component applies.
+// The prepared-pack shape (HANDOFF-CARDS-ACTIONS-MENTIONS K3/K4): staged
+// context serializes to the pack with the originating object always first,
+// and the pack equals the visible chip set exactly (the named invariant of
+// the round; K7's probe asserts it). The delegate wire submits this shape.
+
+import type { StagedContextChip } from './shell-store';
+
+export type ActionDestination = 'for-me' | 'with-me';
+export type ActionFollowUp = 'mark-handled' | 'keep-open';
+
+export interface PackContextEntry {
+  readonly kind: 'object' | 'selection' | 'file';
+  readonly label: string;
+  readonly object_id?: string;
+  readonly object_type?: string;
+  readonly text?: string;
+}
+
+export interface ActionPack {
+  readonly instruction: string;
+  readonly destination: ActionDestination;
+  readonly follow_up: ActionFollowUp;
+  readonly context: readonly PackContextEntry[];
+}
+
+function entryFromChip(chip: StagedContextChip): PackContextEntry {
+  return {
+    kind: chip.kind,
+    label: chip.label,
+    ...(chip.objectId ? { object_id: chip.objectId } : {}),
+    ...(chip.objectType ? { object_type: chip.objectType } : {}),
+    ...(chip.text ? { text: chip.text } : {}),
+  };
+}
+
+/** Build the pack from exactly the visible chips: origin chips first (the
+ *  originating object leads), then the rest in display order. Nothing is
+ *  added, nothing is dropped; there is no invisible context lane. */
+export function buildActionPack(
+  instruction: string,
+  chips: readonly StagedContextChip[],
+  destination: ActionDestination,
+  followUp: ActionFollowUp,
+): ActionPack {
+  const origin = chips.filter((chip) => chip.source === 'origin');
+  const rest = chips.filter((chip) => chip.source !== 'origin');
+  return {
+    instruction: instruction.trim(),
+    destination,
+    follow_up: followUp,
+    context: [...origin, ...rest].map(entryFromChip),
+  };
+}
+
+/** The invariant probe (K7): true when the pack's context is exactly the
+ *  visible chip set, order-insensitively for non-origin chips but with the
+ *  origin leading. Tests call this; the sheet asserts it before submit. */
+export function packEqualsChips(pack: ActionPack, chips: readonly StagedContextChip[]): boolean {
+  if (pack.context.length !== chips.length) return false;
+  const key = (entry: PackContextEntry) =>
+    `${entry.kind}|${entry.label}|${entry.object_id ?? ''}|${entry.text ?? ''}`;
+  const packKeys = pack.context.map(key).sort();
+  const chipKeys = chips.map((chip) => key(entryFromChip(chip))).sort();
+  if (packKeys.some((value, index) => value !== chipKeys[index])) return false;
+  const firstOrigin = chips.find((chip) => chip.source === 'origin');
+  if (firstOrigin && pack.context.length > 0) {
+    return key(pack.context[0]) === key(entryFromChip(firstOrigin));
+  }
+  return true;
+}
+
diff --git a/apps/console/src/lib/card-templates.test.ts b/apps/console/src/lib/card-templates.test.ts
new file mode 100644
index 00000000..3ba63dbb
--- /dev/null
+++ b/apps/console/src/lib/card-templates.test.ts
@@ -0,0 +1,77 @@
+// K7 (HANDOFF-CARDS-ACTIONS-MENTIONS): template render-model tests across the
+// three seeds plus the malformed-template fixture (degrades to generic with a
+// note, never an error).
+
+import { describe, expect, it } from 'vitest';
+import type { ObjectRef } from '@commonplace/block-view/types';
+import {
+  dynamicFactRows,
+  parseCardTemplate,
+  resolveCardTemplate,
+  seedCardTemplates,
+} from './card-templates';
+
+const MALFORMED: ObjectRef = {
+  id: 'card-template-broken',
+  type: 'card_template',
+  properties: { kind: 'person', template: { kind: 'person', identity: {} } },
+};
+
+describe('card templates', () => {
+  it('parses the three seeded templates', () => {
+    for (const seed of seedCardTemplates()) {
+      const parsed = parseCardTemplate(seed);
+      expect(parsed.spec, `seed ${seed.id}`).not.toBeNull();
+      expect(parsed.note).toBeUndefined();
+    }
+  });
+
+  it('the person template binds identity, facts, chips', () => {
+    const templates = seedCardTemplates();
+    const person = resolveCardTemplate(templates, 'person');
+    expect(person.fallbackNote).toBeUndefined();
+    expect(person.spec.identity.titleField).toBe('title');
+    expect(person.spec.chips.map((chip) => chip.edge)).toEqual([
+      'WORKS_AT',
+      'HAS_SKILL',
+      'IN_PROJECT',
+    ]);
+  });
+
+  it('the task template carries the progress gauge', () => {
+    const task = resolveCardTemplate(seedCardTemplates(), 'task');
+    expect(task.spec.gauges).toEqual([
+      { kind: 'progress', field: 'progress', max: 100, label: 'Progress' },
+    ]);
+  });
+
+  it('an unknown kind resolves to the generic card, never an error', () => {
+    const resolved = resolveCardTemplate(seedCardTemplates(), 'squirrel');
+    expect(resolved.spec.kind).toBe('generic');
+    expect(resolved.fallbackNote).toBeUndefined();
+  });
+
+  it('a malformed template degrades to generic with a note', () => {
+    const templates = [MALFORMED, ...seedCardTemplates().filter((t) => t.properties.kind !== 'person')];
+    const resolved = resolveCardTemplate(templates, 'person');
+    expect(resolved.spec.kind).toBe('generic');
+    expect(resolved.fallbackNote).toMatch(/identity\.titleField/);
+  });
+
+  it('generic dynamic facts skip identity fields and non-scalars', () => {
+    const generic = resolveCardTemplate(seedCardTemplates(), 'anything').spec;
+    const object: ObjectRef = {
+      id: 'x1',
+      type: 'anything',
+      properties: {
+        title: 'A thing',
+        status: 'open',
+        nested: { deep: true },
+        count: 3,
+        gone: null,
+      },
+    };
+    const rows = dynamicFactRows(object, generic);
+    expect(rows.map((row) => row.field)).toEqual(['status', 'count']);
+  });
+});
diff --git a/apps/console/src/lib/card-templates.ts b/apps/console/src/lib/card-templates.ts
new file mode 100644
index 00000000..b18f006b
--- /dev/null
+++ b/apps/console/src/lib/card-templates.ts
@@ -0,0 +1,248 @@
+// SOURCING: @commonplace/block-view (ObjectRef; templates are objects on the
+// data seam). Card templates are kind-templated layouts stored as data
+// (HANDOFF-CARDS-ACTIONS-MENTIONS named choice 1): one engine renders any
+// template; adding a kind's card is authoring a template object, not a
+// component. This module owns the template shape, validation, the seeded
+// person/task/generic templates, and kind resolution with the generic
+// fallback (a malformed or missing template degrades, never errors).
+
+import type { JsonValue, ObjectRef } from '@commonplace/block-view/types';
+
+export const CARD_TEMPLATE_TYPE = 'card_template';
+
+/** The identity strip at the card's head: title, optional subtitle fields,
+ *  optional image ref (the strip renders its no-image state until a kind
+ *  carries one; verify-first note in the handoff). */
+export interface CardIdentitySpec {
+  readonly titleField: string;
+  readonly subtitleFields?: readonly string[];
+  readonly imageField?: string;
+}
+
+export interface CardFactSpec {
+  readonly field: string;
+  readonly label?: string;
+}
+
+/** A relation chip is a live object reference: clicking one opens the related
+ *  object's card (named choice 2). `targetKind` is the type hint the opener
+ *  passes so cross-kind resolution can query the right types. */
+export interface CardChipSpec {
+  readonly edge: string;
+  readonly targetKind?: string;
+  readonly label?: string;
+}
+
+/** Kind-specific gauges; progress is the seeded family (a task's progress
+ *  bar). `field` holds 0..max. */
+export interface CardGaugeSpec {
+  readonly kind: 'progress';
+  readonly field: string;
+  readonly max?: number;
+  readonly label?: string;
+}
+
+export interface CardTemplateSpec {
+  readonly kind: string;
+  readonly identity: CardIdentitySpec;
+  readonly facts: readonly CardFactSpec[];
+  /** When true and `facts` is empty, the engine derives fact rows from the
+   *  object's own scalar properties (the generic card's behavior). */
+  readonly dynamicFacts?: boolean;
+  readonly chips: readonly CardChipSpec[];
+  readonly gauges: readonly CardGaugeSpec[];
+}
+
+export interface ParsedCardTemplate {
+  readonly spec: CardTemplateSpec | null;
+  /** Present when the stored template failed validation: the engine falls
+   *  back to generic and surfaces this note (K7 malformed fixture). */
+  readonly note?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function stringArray(value: unknown): readonly string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.filter((entry): entry is string => typeof entry === 'string');
+}
+
+/** Validate a stored template payload into a spec, or return the named
+ *  failure. Every field access is defensive: template objects are data and
+ *  arrive from the seam, not from code. */
+export function parseCardTemplate(ref: ObjectRef): ParsedCardTemplate {
+  const raw = ref.properties.template;
+  if (!isRecord(raw)) {
+    return { spec: null, note: `template object ${ref.id} carries no template payload` };
+  }
+  const kind = raw.kind;
+  const identity = raw.identity;
+  if (typeof kind !== 'string' || !kind) {
+    return { spec: null, note: `template object ${ref.id} is missing its kind` };
+  }
+  if (!isRecord(identity) || typeof identity.titleField !== 'string' || !identity.titleField) {
+    return { spec: null, note: `template for "${kind}" has no identity.titleField` };
+  }
+  const facts: CardFactSpec[] = [];
+  if (Array.isArray(raw.facts)) {
+    for (const entry of raw.facts) {
+      if (isRecord(entry) && typeof entry.field === 'string' && entry.field) {
+        facts.push({ field: entry.field, label: typeof entry.label === 'string' ? entry.label : undefined });
+      }
+    }
+  }
+  const chips: CardChipSpec[] = [];
+  if (Array.isArray(raw.chips)) {
+    for (const entry of raw.chips) {
+      if (isRecord(entry) && typeof entry.edge === 'string' && entry.edge) {
+        chips.push({
+          edge: entry.edge,
+          targetKind: typeof entry.targetKind === 'string' ? entry.targetKind : undefined,
+          label: typeof entry.label === 'string' ? entry.label : undefined,
+        });
+      }
+    }
+  }
+  const gauges: CardGaugeSpec[] = [];
+  if (Array.isArray(raw.gauges)) {
+    for (const entry of raw.gauges) {
+      if (isRecord(entry) && entry.kind === 'progress' && typeof entry.field === 'string' && entry.field) {
+        gauges.push({
+          kind: 'progress',
+          field: entry.field,
+          max: typeof entry.max === 'number' && entry.max > 0 ? entry.max : undefined,
+          label: typeof entry.label === 'string' ? entry.label : undefined,
+        });
+      }
+    }
+  }
+  return {
+    spec: {
+      kind,
+      identity: {
+        titleField: identity.titleField,
+        subtitleFields: stringArray(identity.subtitleFields),
+        imageField: typeof identity.imageField === 'string' ? identity.imageField : undefined,
+      },
+      facts,
+      dynamicFacts: raw.dynamicFacts === true,
+      chips,
+      gauges,
+    },
+  };
+}
+
+export const GENERIC_TEMPLATE_ID = 'card-template-generic';
+
+function templateObject(kind: string, template: Record<string, JsonValue>): ObjectRef {
+  return {
+    id: kind === 'generic' ? GENERIC_TEMPLATE_ID : `card-template-${kind}`,
+    type: CARD_TEMPLATE_TYPE,
+    properties: { kind, title: `${kind} card`, template },
+  };
+}
+
+/** The three seeded templates (K1): person, task, generic. Skills, orgs, and
+ *  projects are objects reached through chips, not strings. */
+export function seedCardTemplates(): ObjectRef[] {
+  return [
+    templateObject('person', {
+      kind: 'person',
+      identity: { titleField: 'title', subtitleFields: ['role'], imageField: 'image' },
+      facts: [
+        { field: 'email', label: 'Email' },
+        { field: 'location', label: 'Location' },
+      ],
+      chips: [
+        { edge: 'WORKS_AT', targetKind: 'org', label: 'Org' },
+        { edge: 'HAS_SKILL', targetKind: 'skill', label: 'Skills' },
+        { edge: 'IN_PROJECT', targetKind: 'project', label: 'Projects' },
+      ],
+      gauges: [],
+    }),
+    templateObject('task', {
+      kind: 'task',
+      identity: { titleField: 'title', subtitleFields: ['status'] },
+      facts: [
+        { field: 'status', label: 'Status' },
+        { field: 'priority', label: 'Priority' },
+        { field: 'due', label: 'Due' },
+      ],
+      chips: [
+        { edge: 'IN_PROJECT', targetKind: 'project', label: 'Project' },
+        { edge: 'DEPENDS_ON', targetKind: 'task', label: 'Depends on' },
+      ],
+      gauges: [{ kind: 'progress', field: 'progress', max: 100, label: 'Progress' }],
+    }),
+    templateObject('generic', {
+      kind: 'generic',
+      identity: { titleField: 'title' },
+      facts: [],
+      dynamicFacts: true,
+      chips: [],
+      gauges: [],
+    }),
+  ];
+}
+
+export interface ResolvedCardTemplate {
+  readonly spec: CardTemplateSpec;
+  /** Set when resolution fell back to generic because the kind's template was
+   *  missing or malformed; the card surfaces the note honestly. */
+  readonly fallbackNote?: string;
+}
+
+const BUILTIN_GENERIC: CardTemplateSpec = {
+  kind: 'generic',
+  identity: { titleField: 'title' },
+  facts: [],
+  dynamicFacts: true,
+  chips: [],
+  gauges: [],
+};
+
+/** Resolve the template for an object kind against the template objects the
+ *  seam served. An object of a kind with no template renders the generic
+ *  card, never an error (K1 acceptance). */
+export function resolveCardTemplate(
+  templates: readonly ObjectRef[],
+  kind: string,
+): ResolvedCardTemplate {
+  const parsedByKind = new Map<string, ParsedCardTemplate>();
+  for (const ref of templates) {
+    const declared = typeof ref.properties.kind === 'string' ? ref.properties.kind : '';
+    if (declared && !parsedByKind.has(declared)) parsedByKind.set(declared, parseCardTemplate(ref));
+  }
+  const exact = parsedByKind.get(kind);
+  if (exact?.spec) return { spec: exact.spec };
+  const generic = parsedByKind.get('generic');
+  const genericSpec = generic?.spec ?? BUILTIN_GENERIC;
+  if (exact && !exact.spec) {
+    return { spec: genericSpec, fallbackNote: exact.note ?? `template for "${kind}" is malformed` };
+  }
+  return { spec: genericSpec };
+}
+
+/** The dynamic fact rows for the generic card: the object's scalar properties
+ *  minus the identity fields, capped so the card stays a card. */
+export function dynamicFactRows(
+  object: ObjectRef,
+  spec: CardTemplateSpec,
+  cap = 5,
+): readonly CardFactSpec[] {
+  const excluded = new Set<string>([
+    spec.identity.titleField,
+    ...(spec.identity.subtitleFields ?? []),
+    spec.identity.imageField ?? '',
+  ]);
+  const rows: CardFactSpec[] = [];
+  for (const [field, value] of Object.entries(object.properties)) {
+    if (excluded.has(field)) continue;
+    if (value === null || typeof value === 'object') continue;
+    rows.push({ field });
+    if (rows.length >= cap) break;
+  }
+  return rows;
+}
diff --git a/apps/console/src/lib/console-host.test.ts b/apps/console/src/lib/console-host.test.ts
index 47f5f310..6f733d72 100644
--- a/apps/console/src/lib/console-host.test.ts
+++ b/apps/console/src/lib/console-host.test.ts
@@ -42,6 +42,7 @@ describe('ConsoleBlockHost', () => {
     const set = host.queryLayout(surfaceQuery());
     const surfaces = set.objects.filter((object) => object.type === 'surface');
     expect(surfaces.map((surface) => surface.id).sort()).toEqual([
+      'console-cards',
       'console-docs',
       'console-index',
       'console-review',
diff --git a/apps/console/src/lib/console-host.ts b/apps/console/src/lib/console-host.ts
index 2c4c155a..4c8f7c79 100644
--- a/apps/console/src/lib/console-host.ts
+++ b/apps/console/src/lib/console-host.ts
@@ -23,6 +23,7 @@ import type {
 import { CONTAINS_EDGE } from '@commonplace/block-view/surface-tree';
 import { HttpBlockHost } from '@commonplace/block-view/host/http';
 import { RECORD_FIELDS, seedCodeFiles, seedDocs, seedLayout } from './workspace-seed';
+import { CARD_TEMPLATE_TYPE, seedCardTemplates } from './card-templates';
 
 const LAYOUT_TYPES = new Set(['surface', 'region', 'view-instance']);
 const STORAGE_KEY = 'commonplace.console.surface.v1';
@@ -124,6 +125,7 @@ export class ConsoleBlockHost implements BlockHost {
   private records: ObjectRef[] | null;
   private docs: ObjectRef[];
   private codeFiles: ObjectRef[];
+  private cardTemplates: ObjectRef[];
   private layoutSubs = new Set<() => void>();
   private domainSubs = new Set<() => void>();
   private registry: Registry;
@@ -142,6 +144,10 @@ export class ConsoleBlockHost implements BlockHost {
     });
     this.docs = seedDocs();
     this.codeFiles = seedCodeFiles();
+    // Card templates are seeded objects served through this seam (K1): the
+    // card engine queries them like any record, and the Model surface edits
+    // them later through the same update action.
+    this.cardTemplates = seedCardTemplates();
     this.hydrateLayout();
   }
 
@@ -211,18 +217,38 @@ export class ConsoleBlockHost implements BlockHost {
 
   query(query: ObjectQuery): ObjectSet | Promise<ObjectSet> {
     if (query.types.some((type) => LAYOUT_TYPES.has(type))) return this.layoutSet(query);
-    // Records and typed HunkSets are live wires (R2.1/H3): they round-trip
-    // through the same object seam and never compile review logic in React.
-    if (query.types.includes('hunk') || (query.types.includes('record') && this.records === null)) {
+    // The live wire is the default (R2.1): records, hunks, and every domain
+    // kind the seam serves (person, task, mention-candidate, ...) round-trip
+    // through the data API proxy. Documents and code files ride the live wire
+    // too so edits persist to the backend (the file-editing fix): the backend
+    // is the source of truth, but the console filters/sorts/pages client-side
+    // so slug and id predicates behave exactly as the seed path did.
+    // Console-owned seeds stay local: card templates (K1, authored objects)
+    // and 'thread' (the pane renders its own chat SSE, never the record wire).
+    const testMode = this.records !== null;
+    const isRecord = query.types.includes('record');
+    const isDoc = query.types.includes('doc');
+    const isCode = query.types.includes('code-file');
+    // Console-local kinds never touch the wire: 'thread' (its pane renders its
+    // own chat SSE) and card templates (K1, console-authored seeds).
+    const consoleLocal =
+      query.types.includes('thread') || query.types.includes(CARD_TEMPLATE_TYPE);
+    if (!testMode && !consoleLocal) {
+      // Docs and code files are client-filtered so slug/id predicates resolve
+      // exactly as the seed path did; every other seam kind (record, person,
+      // task, project, org, mention-candidate, hunk, ...) filters API-side.
+      if (isDoc || isCode) return this.queryLiveDomain(query, isDoc ? 'doc' : 'code-file');
       return this.http.query(query);
     }
-    const pool = query.types.includes('record')
+    const pool = isRecord
       ? (this.records ?? [])
-      : query.types.includes('doc')
+      : isDoc
         ? this.docs
-        : query.types.includes('code-file')
+        : isCode
           ? this.codeFiles
-          : [];
+          : query.types.includes(CARD_TEMPLATE_TYPE)
+            ? this.cardTemplates
+            : [];
     let objects = pool.filter((object) => matchesPredicate(object, query.where));
     const ranker = query.rank?.[0];
     if (ranker?.kind === 'field') {
@@ -259,6 +285,83 @@ export class ConsoleBlockHost implements BlockHost {
     };
   }
 
+  /** Documents and code files over the live wire: fetch the kind from the
+   *  backend, then filter, sort, and page with the console's own client logic
+   *  so a `where slug eq` or `where path eq` predicate resolves identically to
+   *  the former seed path (no dependency on the API's predicate support). */
+  private async queryLiveDomain(query: ObjectQuery, type: string): Promise<ObjectSet> {
+    const all = await this.http.query({ types: [type], page: { limit: 500 } });
+    let objects = all.objects.filter((object) => matchesPredicate(object, query.where));
+    const ranker = query.rank?.[0];
+    if (ranker?.kind === 'field') {
+      const direction = ranker.direction === 'desc' ? -1 : 1;
+      objects = [...objects].sort(
+        (a, b) => direction * compareValues(a.properties[ranker.field], b.properties[ranker.field]),
+      );
+    }
+    let nextCursor: string | undefined;
+    if (query.page) {
+      const offset = query.page.cursor ? Number.parseInt(query.page.cursor, 10) || 0 : 0;
+      const end = offset + query.page.limit;
+      if (end < objects.length) nextCursor = String(end);
+      objects = objects.slice(offset, end);
+    }
+    return {
+      objects,
+      shape: {
+        types: [...query.types],
+        fields: Object.keys(objects[0]?.properties ?? {}),
+        relations: [],
+        axes: {},
+        cardinality: objects.length === 0 ? 'empty' : objects.length === 1 ? 'one' : 'many',
+      },
+      next_cursor: nextCursor,
+      subscribe: () => () => {},
+    };
+  }
+
+  /** Seed the backend with the console's document fixtures once, keyed by slug
+   *  and path, so the deployed (in-memory, resets on restart) API has editable,
+   *  persistent content instead of client-only seeds. Content rides as extra
+   *  properties (markdown / content) so the projection returns exactly what the
+   *  Galley and CodeMirror views read. Idempotent: absent keys only. */
+  async ensureSeedContent(): Promise<void> {
+    if (this.records !== null) return;
+    try {
+      const existingDocs = await this.http.query({ types: ['doc'], page: { limit: 200 } });
+      const slugs = new Set(existingDocs.objects.map((object) => object.properties.slug));
+      for (const doc of this.docs) {
+        if (slugs.has(doc.properties.slug)) continue;
+        await this.http.emit({
+          kind: 'create',
+          type: 'doc',
+          props: {
+            title: doc.properties.title,
+            slug: doc.properties.slug,
+            markdown: doc.properties.markdown,
+          },
+        });
+      }
+      const existingCode = await this.http.query({ types: ['code-file'], page: { limit: 200 } });
+      const paths = new Set(existingCode.objects.map((object) => object.properties.path));
+      for (const file of this.codeFiles) {
+        if (paths.has(file.properties.path)) continue;
+        await this.http.emit({
+          kind: 'create',
+          type: 'code-file',
+          props: {
+            title: file.properties.path,
+            path: file.properties.path,
+            language: file.properties.language,
+            content: file.properties.content,
+          },
+        });
+      }
+    } catch {
+      // Backend unreachable: the Documents surface renders its empty state.
+    }
+  }
+
   /** The arrangement branch is always synchronous and local: the shell's
    *  layout store reads it without awaiting. */
   queryLayout(query: ObjectQuery): ObjectSet {
@@ -314,9 +417,14 @@ export class ConsoleBlockHost implements BlockHost {
           this.notifyLayout();
           return Promise.resolve(applied([action.id]));
         }
-        // Docs and code files patch in-session (seed content); record
-        // updates ride the live wire when no test pool is present.
-        for (const pool of [this.records ?? [], this.docs, this.codeFiles]) {
+        // In live mode only card templates patch in-session (console-authored
+        // seeds); records, docs, and code files ride the wire so edits persist.
+        // In test mode the local pools carry every kind.
+        const updatePools =
+          this.records === null
+            ? [this.cardTemplates]
+            : [this.records, this.docs, this.codeFiles, this.cardTemplates];
+        for (const pool of updatePools) {
           const index = pool.findIndex((object) => object.id === action.id);
           if (index >= 0) {
             pool[index] = { ...pool[index], properties: { ...pool[index].properties, ...action.patch } };
diff --git a/apps/console/src/lib/shell-store.ts b/apps/console/src/lib/shell-store.ts
index e39cb861..c797a4d7 100644
--- a/apps/console/src/lib/shell-store.ts
+++ b/apps/console/src/lib/shell-store.ts
@@ -4,9 +4,28 @@
 // only; the durable arrangement lives in the surface object via ConsoleBlockHost.
 
 import { create } from 'zustand';
+import type { ObjectRef } from '@commonplace/block-view/types';
 
 export type ConnectionState = 'connected' | 'connecting' | 'disconnected' | 'identity-refused';
 
+/** A staged context chip on the action sheet (HANDOFF-CARDS-ACTIONS-MENTIONS
+ *  named choice 4): context is never silent; every chip is visible and
+ *  removable, and the submitted pack equals this list exactly. */
+export interface StagedContextChip {
+  readonly id: string;
+  readonly kind: 'object' | 'selection' | 'file';
+  readonly label: string;
+  readonly objectId?: string;
+  readonly objectType?: string;
+  readonly text?: string;
+  readonly source: 'origin' | 'manual' | 'auto';
+}
+
+export interface ActionSheetOrigin {
+  readonly instruction?: string;
+  readonly chips: readonly StagedContextChip[];
+}
+
 /** The island's four modes (HANDOFF-CONSOLE-ROUND-2 named choice 2). */
 export type OmnibarMode = 'ask' | 'command' | 'search' | 'objects';
 
@@ -21,7 +40,13 @@ export interface ShellState {
   toggleReducedMotionPreview(): void;
   /** Selected record id; opens the inspector tool window (G6). */
   selectedRecordId: string | null;
-  selectRecord(id: string | null): void;
+  /** The selected object when the opener already held it (a table row, a grid
+   *  cell); saves the inspector a refetch. Null means fetch by id. */
+  selectedRecordObject: ObjectRef | null;
+  /** Type hint for cross-kind fetches: a relation chip knows its target kind
+   *  (K1 named choice 2) so the inspector can query the right types. */
+  selectedTypeHint: string | null;
+  selectRecord(id: string | null, object?: ObjectRef | null, typeHint?: string | null): void;
   /** Connection state surfaced in the status bar, incl. the named identity-refusal state. */
   connection: ConnectionState;
   setConnection(state: ConnectionState): void;
@@ -34,6 +59,10 @@ export interface ShellState {
   setProgress(label: string | null): void;
   /** Tenant identity shown in the status bar. Slug casing is load-bearing. */
   tenant: string;
+  /** The action sheet (K3): one sheet, three entries, identical everywhere. */
+  actionSheetOrigin: ActionSheetOrigin | null;
+  openActionSheet(origin: ActionSheetOrigin): void;
+  closeActionSheet(): void;
 }
 
 export const useShellStore = create<ShellState>((set) => ({
@@ -45,7 +74,10 @@ export const useShellStore = create<ShellState>((set) => ({
   toggleReducedMotionPreview: () =>
     set((state) => ({ reducedMotionPreview: !state.reducedMotionPreview })),
   selectedRecordId: null,
-  selectRecord: (id) => set({ selectedRecordId: id }),
+  selectedRecordObject: null,
+  selectedTypeHint: null,
+  selectRecord: (id, object = null, typeHint = null) =>
+    set({ selectedRecordId: id, selectedRecordObject: object, selectedTypeHint: typeHint }),
   connection: 'disconnected',
   setConnection: (state) => set({ connection: state }),
   presenceCount: null,
@@ -53,4 +85,18 @@ export const useShellStore = create<ShellState>((set) => ({
   progressLabel: null,
   setProgress: (label) => set({ progressLabel: label }),
   tenant: 'Travis-Gilbert',
+  actionSheetOrigin: null,
+  openActionSheet: (origin) => set({ actionSheetOrigin: origin }),
+  closeActionSheet: () => set({ actionSheetOrigin: null }),
 }));
+
+/** The staged chip for an object entry: the originating object rides first in
+ *  the pack, so openers build it through this helper for a stable shape. */
+export function objectChip(
+  id: string,
+  type: string,
+  label: string,
+  source: StagedContextChip['source'] = 'origin',
+): StagedContextChip {
+  return { id: `chip-object-${id}`, kind: 'object', label, objectId: id, objectType: type, source };
+}
diff --git a/apps/console/src/lib/thread-store.ts b/apps/console/src/lib/thread-store.ts
index 7c8f7b46..ae96fb12 100644
--- a/apps/console/src/lib/thread-store.ts
+++ b/apps/console/src/lib/thread-store.ts
@@ -21,12 +21,24 @@ export interface ThreadMessage {
   parts: ThreadTextPart[];
 }
 
+/** An object reference staged into the thread by the action sheet's With-me
+ *  path (HANDOFF-CARDS-ACTIONS-MENTIONS K4): visible above the composer,
+ *  travels with the next message, removable until sent. */
+export interface StagedThreadRef {
+  readonly id: string;
+  readonly label: string;
+  readonly objectId?: string;
+}
+
 export interface ThreadState {
   messages: ThreadMessage[];
   isRunning: boolean;
   error: string | null;
   abort: AbortController | null;
   endpoint: string | null;
+  staged: StagedThreadRef[];
+  stage(refs: readonly StagedThreadRef[]): void;
+  unstage(id: string): void;
   send(text: string): Promise<void>;
   cancel(): void;
 }
@@ -57,10 +69,30 @@ export const useThreadStore = create<ThreadState>((set, get) => ({
   error: null,
   abort: null,
   endpoint: chatEndpoint(),
+  staged: [],
+
+  stage(refs) {
+    set((state) => {
+      const seen = new Set(state.staged.map((ref) => ref.id));
+      return { staged: [...state.staged, ...refs.filter((ref) => !seen.has(ref.id))] };
+    });
+  },
+
+  unstage(id) {
+    set((state) => ({ staged: state.staged.filter((ref) => ref.id !== id) }));
+  },
 
-  async send(text: string) {
+  async send(rawText: string) {
     const endpoint = get().endpoint;
     if (!endpoint || get().isRunning) return;
+    // Staged references travel with the message and clear once sent; they
+    // were visible chips the whole time (no invisible context lane).
+    const staged = get().staged;
+    const refLine = staged
+      .map((ref) => (ref.objectId ? `@[${ref.label}](${ref.objectId})` : ref.label))
+      .join(' ');
+    const text = refLine ? `${rawText}\n${refLine}` : rawText;
+    if (staged.length > 0) set({ staged: [] });
     const userMessage: ThreadMessage = { id: nextId(), role: 'user', parts: [{ type: 'text', text }] };
     const assistantMessage: ThreadMessage = { id: nextId(), role: 'assistant', parts: [{ type: 'text', text: '' }] };
     const abort = new AbortController();
diff --git a/apps/console/src/lib/workspace-seed.ts b/apps/console/src/lib/workspace-seed.ts
index 6df7b289..7fa27e45 100644
--- a/apps/console/src/lib/workspace-seed.ts
+++ b/apps/console/src/lib/workspace-seed.ts
@@ -110,6 +110,29 @@ export function seedLayout(): ObjectRef[] {
       query: { types: ['record'], live: true } as unknown as JsonValue,
     }),
 
+    // Cards: the cards.grid mount (HANDOFF-CARDS-ACTIONS-MENTIONS K2): an
+    // ObjectQuery rendered as faces at Twenty density for browsing people,
+    // projects, and tasks. The query rides the live wire; an empty store
+    // renders the honest empty state.
+    layoutObject('console-cards', 'surface', { name: 'Cards', kind: 'cards', active: false }, [
+      'cards.region-editor',
+    ]),
+    layoutObject(
+      'cards.region-editor',
+      'region',
+      { kind: 'editor', size: 100, active_tab: 'cards.vi-grid' },
+      ['cards.vi-grid'],
+    ),
+    layoutObject('cards.vi-grid', 'view-instance', {
+      descriptor_id: 'cards.grid',
+      title: 'Cards',
+      query: {
+        types: ['person', 'task', 'project', 'org'],
+        page: { limit: 400 },
+        live: true,
+      } as unknown as JsonValue,
+    }),
+
     // Documents: list left, Galley reading view center, thread on its stripe
     // (closed by default) (R3.2).
     layoutObject('console-docs', 'surface', { name: 'Documents', kind: 'documents', active: false }, [
@@ -262,6 +285,24 @@ object, not component state. Toggle the tool windows from the stripes.
 Double-press Shift for search everywhere.
 `;
 
+const CONSOLE_PUNCH_LIST = `# Console punch list
+
+Working notes for the console itself. Each todo carries the action affordance:
+the arrow at the end of a line (or Alt Enter with the line focused) hands that
+item to the agent through the action sheet.
+
+## Open items
+
+- [ ] Wire the destination rail to live connector counts
+- [ ] Capture a fresh visual baseline after the card engine lands
+- [x] Point the record table at the deployed object seam
+
+## Notes
+
+The sheet stages this document plus the todo line as visible context; nothing
+travels unseen.
+`;
+
 export function seedDocs(): ObjectRef[] {
   return [
     {
@@ -273,6 +314,15 @@ export function seedDocs(): ObjectRef[] {
         markdown: CONSOLE_BRIEF,
       },
     },
+    {
+      id: 'doc-console-punch-list',
+      type: 'doc',
+      properties: {
+        slug: 'console-punch-list',
+        title: 'Console punch list',
+        markdown: CONSOLE_PUNCH_LIST,
+      },
+    },
   ];
 }
 
diff --git a/apps/console/src/motion/motion-tokens.ts b/apps/console/src/motion/motion-tokens.ts
index 90ca5b1d..a783892a 100644
--- a/apps/console/src/motion/motion-tokens.ts
+++ b/apps/console/src/motion/motion-tokens.ts
@@ -93,6 +93,12 @@ export const INTERACTION_INVENTORY = [
     spec: 'DUR.fast open, EASE_OUT',
     reducedMotion: 'expansion renders as a plain fade (R1 acceptance), no scale',
   },
+  {
+    trigger: 'Action sheet opens',
+    effect: 'scale 0.98 to 1 plus fade on the composer material at reduced scale',
+    spec: 'DUR.fast, EASE_OUT',
+    reducedMotion: 'renders without the material animation (K3 acceptance): plain fade, no scale',
+  },
   {
     trigger: 'Thread message appears',
     effect: 'opacity 0 to 1, y 6 to 0',
diff --git a/apps/console/src/views/CardView.tsx b/apps/console/src/views/CardView.tsx
new file mode 100644
index 00000000..c09f0b1f
--- /dev/null
+++ b/apps/console/src/views/CardView.tsx
@@ -0,0 +1,382 @@
+'use client';
+
+// SOURCING: @commonplace/block-view (host query/emit; templates and objects
+// arrive through the seam) + @tanstack/react-virtual (ledger row: row
+// virtualization) for the card grid. The card engine (K1): one renderer for
+// any kind-templated card. `card.full` mounts in panes and documents,
+// `card.compact` in the inspector head and popovers, `cards.grid` renders an
+// ObjectQuery as faces at Twenty density. Structure uses --rec-* metrics,
+// paint is the Int UI register.
+
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useVirtualizer } from '@tanstack/react-virtual';
+import type {
+  BlockHost,
+  JsonValue,
+  ObjectRef,
+  ViewRenderProps,
+} from '@commonplace/block-view/types';
+import {
+  CARD_TEMPLATE_TYPE,
+  dynamicFactRows,
+  resolveCardTemplate,
+  type CardChipSpec,
+  type ResolvedCardTemplate,
+} from '@/lib/card-templates';
+import { objectChip, useShellStore } from '@/lib/shell-store';
+import { MentionsSection, UnlinkedMentionsChip } from './MentionsSection';
+import { ViewState } from './ViewStates';
+
+/** Templates are objects: the engine queries them through the same seam any
+ *  record rides. The set is tiny and stable; one query per mounted surface. */
+export function useCardTemplates(host: BlockHost): readonly ObjectRef[] {
+  const [templates, setTemplates] = useState<readonly ObjectRef[]>([]);
+  useEffect(() => {
+    let active = true;
+    let unsubscribe: (() => void) | undefined;
+    Promise.resolve(host.query({ types: [CARD_TEMPLATE_TYPE] }))
+      .then((set) => {
+        if (!active) return;
+        setTemplates(set.objects);
+        unsubscribe = set.subscribe((next) => {
+          if (active) setTemplates(next.objects);
+        });
+      })
+      .catch(() => {
+        // No templates reachable: every card renders generic, never an error.
+        if (active) setTemplates([]);
+      });
+    return () => {
+      active = false;
+      unsubscribe?.();
+    };
+  }, [host]);
+  return templates;
+}
+
+function textValue(value: JsonValue | undefined): string {
+  if (value === undefined || value === null) return '';
+  if (Array.isArray(value)) return value.map((entry) => String(entry)).join(', ');
+  if (typeof value === 'object') return '';
+  return String(value);
+}
+
+/** Resolve chip target titles: one bounded query per target kind, mapped by
+ *  id. Unresolved ids still render (the id is the honest fallback label). */
+function useChipTitles(
+  host: BlockHost,
+  object: ObjectRef,
+  chips: readonly CardChipSpec[],
+): ReadonlyMap<string, string> {
+  const kinds = useMemo(() => {
+    const wanted = new Set<string>();
+    for (const chip of chips) {
+      const related = object.relations?.[chip.edge] ?? [];
+      if (related.length > 0 && chip.targetKind) wanted.add(chip.targetKind);
+    }
+    return [...wanted].sort();
+  }, [chips, object]);
+  const [titles, setTitles] = useState<ReadonlyMap<string, string>>(new Map());
+
+  useEffect(() => {
+    if (kinds.length === 0) return;
+    let active = true;
+    Promise.resolve(host.query({ types: kinds, page: { limit: 200 } }))
+      .then((set) => {
+        if (!active) return;
+        const next = new Map<string, string>();
+        for (const target of set.objects) {
+          next.set(target.id, textValue(target.properties.title) || target.id);
+        }
+        setTitles(next);
+      })
+      .catch(() => {
+        // Titles stay ids; the chip still opens the object.
+      });
+    return () => {
+      active = false;
+    };
+  }, [host, kinds]);
+  return titles;
+}
+
+export type CardSize = 'full' | 'compact';
+
+export interface RecordCardProps {
+  readonly object: ObjectRef;
+  readonly host: BlockHost;
+  readonly size: CardSize;
+  /** Extra sections a mount injects under the facts (the Mentions section
+   *  mounts here in K6). */
+  readonly children?: React.ReactNode;
+}
+
+/** The card engine: renders any object through its kind's template. */
+export function RecordCard({ object, host, size, children }: RecordCardProps) {
+  const templates = useCardTemplates(host);
+  const resolved = useMemo(
+    () => resolveCardTemplate(templates, object.type),
+    [templates, object.type],
+  );
+  return (
+    <ResolvedCard object={object} host={host} size={size} resolved={resolved}>
+      {children}
+    </ResolvedCard>
+  );
+}
+
+function ResolvedCard({
+  object,
+  host,
+  size,
+  resolved,
+  children,
+}: RecordCardProps & { readonly resolved: ResolvedCardTemplate }) {
+  const selectRecord = useShellStore((state) => state.selectRecord);
+  const openActionSheet = useShellStore((state) => state.openActionSheet);
+  const { spec, fallbackNote } = resolved;
+  const title = textValue(object.properties[spec.identity.titleField]) || object.id;
+  const subtitle = (spec.identity.subtitleFields ?? [])
+    .map((field) => textValue(object.properties[field]))
+    .filter(Boolean)
+    .join(' · ');
+  const image = spec.identity.imageField
+    ? textValue(object.properties[spec.identity.imageField])
+    : '';
+  const facts =
+    spec.facts.length > 0 || !spec.dynamicFacts ? spec.facts : dynamicFactRows(object, spec);
+  const chipTitles = useChipTitles(host, object, spec.chips);
+
+  return (
+    <article
+      data-card={size}
+      data-card-kind={spec.kind}
+      className="rounded-ij-arc border border-ij-seam-raised bg-ij-raised"
+    >
+      <header className="flex items-center gap-2 border-b border-ij-divider p-rec-cell-pad">
+        {image ? (
+          // eslint-disable-next-line @next/next/no-img-element
+          <img
+            src={image}
+            alt=""
+            className="h-8 w-8 shrink-0 rounded-ij-arc object-cover"
+          />
+        ) : (
+          <span
+            aria-hidden
+            data-card-no-image
+            className="flex h-8 w-8 shrink-0 items-center justify-center rounded-ij-arc bg-ij-editor font-ij-mono text-ij-ink-info"
+          >
+            {(title[0] ?? '?').toUpperCase()}
+          </span>
+        )}
+        <div className="min-w-0">
+          <h3 className="truncate text-ij-ink" style={{ fontWeight: 'var(--rec-weight-cap)' }}>
+            {title}
+          </h3>
+          {subtitle ? <p className="truncate text-ij-ink-info">{subtitle}</p> : null}
+        </div>
+        <UnlinkedMentionsChip host={host} object={object} />
+        {size === 'full' ? (
+          <button
+            type="button"
+            data-card-action
+            aria-label={`Hand ${title} to the agent`}
+            onClick={() =>
+              // The Action verb (K3): one of the three entries into the one
+              // sheet, with this object pre-staged as the originating chip.
+              openActionSheet({ chips: [objectChip(object.id, object.type, title)] })
+            }
+            className="ml-2 h-6 shrink-0 rounded-ij-arc border border-ij-control-border bg-ij-editor px-2 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink focus:outline-2 focus:outline-ij-accent"
+            style={{ transition: 'var(--rec-clickable-transition)' }}
+          >
+            Action
+          </button>
+        ) : null}
+      </header>
+
+      {fallbackNote ? (
+        <p data-card-fallback-note className="border-b border-ij-divider p-rec-cell-pad text-ij-ink-info">
+          {fallbackNote}; showing the generic card.
+        </p>
+      ) : null}
+
+      {size === 'full' && spec.gauges.length > 0 ? (
+        <div className="border-b border-ij-divider p-rec-cell-pad">
+          {spec.gauges.map((gauge) => {
+            const rawValue = object.properties[gauge.field];
+            const value = typeof rawValue === 'number' ? rawValue : 0;
+            const max = gauge.max ?? 100;
+            const share = Math.max(0, Math.min(1, max === 0 ? 0 : value / max));
+            return (
+              <div key={gauge.field} className="mb-1 last:mb-0">
+                <div className="flex items-baseline justify-between">
+                  <span className="text-ij-ink-info">{gauge.label ?? gauge.field}</span>
+                  <span className="font-ij-mono text-ij-ink">{Math.round(share * 100)}%</span>
+                </div>
+                <div
+                  role="progressbar"
+                  aria-valuenow={Math.round(share * 100)}
+                  aria-valuemin={0}
+                  aria-valuemax={100}
+                  aria-label={gauge.label ?? gauge.field}
+                  className="mt-1 h-1 w-full overflow-hidden rounded-ij-arc-underline bg-ij-editor"
+                >
+                  <div
+                    className="h-full bg-ij-accent"
+                    style={{ width: `${Math.round(share * 100)}%` }}
+                  />
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      ) : null}
+
+      {size === 'full' && facts.length > 0 ? (
+        <dl className="border-b border-ij-divider p-rec-cell-pad">
+          {facts.map((fact) => {
+            const value = textValue(object.properties[fact.field]);
+            if (!value) return null;
+            return (
+              <div key={fact.field} className="flex items-baseline gap-2 py-px">
+                <dt className="w-24 shrink-0 truncate text-ij-ink-info">
+                  {fact.label ?? fact.field}
+                </dt>
+                <dd className="min-w-0 truncate text-ij-ink">{value}</dd>
+              </div>
+            );
+          })}
+        </dl>
+      ) : null}
+
+      {spec.chips.some((chip) => (object.relations?.[chip.edge] ?? []).length > 0) ? (
+        <div className="flex flex-wrap gap-1 p-rec-cell-pad">
+          {spec.chips.flatMap((chip) =>
+            (object.relations?.[chip.edge] ?? []).map((relatedId) => (
+              <button
+                key={`${chip.edge}:${relatedId}`}
+                type="button"
+                data-card-chip={chip.edge}
+                onClick={(event) => {
+                  // A chip is its own navigation: never let the click fall
+                  // through to a wrapping grid cell's select.
+                  event.stopPropagation();
+                  selectRecord(relatedId, null, chip.targetKind ?? null);
+                }}
+                className="inline-flex h-6 items-center gap-1 rounded-ij-arc border border-ij-control-border bg-ij-editor px-2 text-ij-ink hover:bg-ij-hover-surface focus:outline-2 focus:outline-ij-accent"
+                style={{ transition: 'var(--rec-clickable-transition)' }}
+              >
+                <span className="text-ij-ink-info">{chip.label ?? chip.edge}</span>
+                <span className="max-w-40 truncate">{chipTitles.get(relatedId) ?? relatedId}</span>
+              </button>
+            )),
+          )}
+        </div>
+      ) : null}
+
+      <MentionsSection host={host} object={object} />
+
+      {children}
+    </article>
+  );
+}
+
+/** The `card.full` descriptor render: the first object of the set through its
+ *  template. An empty set renders the shared empty state. */
+export function CardFullView({ set, host }: ViewRenderProps) {
+  const object = set.objects[0];
+  if (!object) return <ViewState state="empty" />;
+  return (
+    <div className="h-full overflow-y-auto p-3">
+      <RecordCard object={object} host={host} size="full" />
+    </div>
+  );
+}
+
+const GRID_MIN_COLUMN = 280;
+const GRID_ROW_ESTIMATE = 128;
+
+/** The `cards.grid` descriptor render (K2): an ObjectQuery as a card grid at
+ *  Twenty density, virtualized past 200 cards, keyboard focus row-major. */
+export function CardGridView({ set, host }: ViewRenderProps) {
+  const scrollRef = useRef<HTMLDivElement | null>(null);
+  const [columns, setColumns] = useState(3);
+
+  useEffect(() => {
+    const node = scrollRef.current;
+    if (!node) return;
+    const measure = () =>
+      setColumns(Math.max(1, Math.floor(node.clientWidth / GRID_MIN_COLUMN)));
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, []);
+
+  const rows = useMemo(() => {
+    const grouped: ObjectRef[][] = [];
+    for (let i = 0; i < set.objects.length; i += columns) {
+      grouped.push(set.objects.slice(i, i + columns) as ObjectRef[]);
+    }
+    return grouped;
+  }, [set.objects, columns]);
+
+  const virtualizer = useVirtualizer({
+    count: rows.length,
+    getScrollElement: () => scrollRef.current,
+    estimateSize: () => GRID_ROW_ESTIMATE,
+    overscan: 4,
+  });
+
+  if (set.objects.length === 0) return <ViewState state="empty" />;
+
+  return (
+    <div
+      ref={scrollRef}
+      data-cards-grid
+      className="h-full overflow-y-auto bg-ij-chrome p-3"
+    >
+      <div className="relative w-full" style={{ height: virtualizer.getTotalSize() }}>
+        {virtualizer.getVirtualItems().map((row) => (
+          <div
+            key={row.key}
+            ref={virtualizer.measureElement}
+            data-index={row.index}
+            className="absolute left-0 top-0 grid w-full gap-2 pb-2"
+            style={{
+              transform: `translateY(${row.start}px)`,
+              gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))`,
+            }}
+          >
+            {rows[row.index]?.map((object) => (
+              <CardGridCell key={object.id} object={object} host={host} />
+            ))}
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function CardGridCell({ object, host }: { object: ObjectRef; host: BlockHost }) {
+  const selectRecord = useShellStore((state) => state.selectRecord);
+  return (
+    <div
+      role="button"
+      tabIndex={0}
+      data-card-cell={object.id}
+      aria-label={`Open ${textValue(object.properties.title) || object.id}`}
+      onClick={() => selectRecord(object.id, object, object.type)}
+      onKeyDown={(event) => {
+        if (event.key === 'Enter' || event.key === ' ') {
+          event.preventDefault();
+          selectRecord(object.id, object, object.type);
+        }
+      }}
+      className="cursor-default focus:outline-2 focus:outline-ij-accent"
+    >
+      <RecordCard object={object} host={host} size="compact" />
+    </div>
+  );
+}
diff --git a/apps/console/src/views/GalleyDocView.tsx b/apps/console/src/views/GalleyDocView.tsx
index 2a82a187..d55a820b 100644
--- a/apps/console/src/views/GalleyDocView.tsx
+++ b/apps/console/src/views/GalleyDocView.tsx
@@ -14,6 +14,7 @@ import { EditorState } from '@codemirror/state';
 import { defaultKeymap, history, historyKeymap } from '@codemirror/commands';
 import { markdown } from '@codemirror/lang-markdown';
 import type { ViewRenderProps } from '@commonplace/block-view/types';
+import { objectChip, useShellStore } from '@/lib/shell-store';
 import { intuiEditorExtensions } from './cm-register-theme';
 import { ViewState } from './ViewStates';
 
@@ -25,6 +26,16 @@ export function GalleyDocView({ set, host }: ViewRenderProps) {
   const [text, setText] = useState<string>(() =>
     typeof doc?.properties.markdown === 'string' ? doc.properties.markdown : '',
   );
+  // Doc navigation patches the reader instance in place (an arrangement
+  // edit), so this component does not remount when the document changes.
+  // Deriving during render (the sanctioned adjust-state-on-prop-change
+  // pattern) resets the edited text to the newly selected document.
+  const [docId, setDocId] = useState<string | undefined>(doc?.id);
+  if (doc && doc.id !== docId) {
+    setDocId(doc.id);
+    setText(typeof doc.properties.markdown === 'string' ? doc.properties.markdown : '');
+    setMode('read');
+  }
   const scrollRef = useRef<HTMLDivElement | null>(null);
   const scrollPos = useRef(0);
   const editorHostRef = useRef<HTMLDivElement | null>(null);
@@ -65,6 +76,69 @@ export function GalleyDocView({ set, host }: ViewRenderProps) {
     if (scroller) scroller.scrollTop = scrollPos.current;
   }, [mode]);
 
+  // The todo-block entry (HANDOFF-CARDS-ACTIONS-MENTIONS K3): every rendered
+  // task-list item gets the action affordance in the paper-plane position,
+  // with Alt+Enter as the shortcut. Galley owns the markup; the decoration
+  // attaches to its .task-list-item output. markdown-theory 0.1.2 styles
+  // that class but its renderer does not yet emit GFM task lists (the same
+  // upstream-gap family as the owl rhythm fix in markdown-theory PR 3), so
+  // until the 0.2.x renderer lands, plain list items that literally begin
+  // with "[ ]" or "[x]" are recognized as todos too.
+  useEffect(() => {
+    if (mode !== 'read') return;
+    const root = scrollRef.current;
+    const docId = doc?.id;
+    const docTitle = typeof doc?.properties.title === 'string' ? doc.properties.title : docId;
+    if (!root || !docId) return;
+    const items = [
+      ...root.querySelectorAll<HTMLElement>('li.task-list-item'),
+      ...[...root.querySelectorAll<HTMLElement>('.galley li:not(.task-list-item)')].filter((li) =>
+        /^\[( |x)\]\s/.test((li.textContent ?? '').trimStart()),
+      ),
+    ];
+    const cleanups: Array<() => void> = [];
+    items.forEach((item) => {
+      const todoText = (item.textContent ?? '').trim();
+      const openFor = () =>
+        useShellStore.getState().openActionSheet({
+          chips: [
+            objectChip(docId, 'doc', docTitle ?? docId),
+            {
+              id: `chip-selection-${docId}-${todoText.slice(0, 24)}`,
+              kind: 'selection',
+              label: todoText,
+              text: todoText,
+              source: 'origin',
+            },
+          ],
+        });
+      const button = document.createElement('button');
+      button.type = 'button';
+      button.dataset.todoAction = '';
+      button.setAttribute('aria-label', 'Hand this todo to the agent');
+      button.textContent = '→';
+      button.className =
+        'ml-2 h-5 rounded-ij-arc px-1 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink focus:outline-2 focus:outline-ij-accent';
+      button.addEventListener('click', openFor);
+      const onKey = (event: KeyboardEvent) => {
+        if (event.altKey && event.key === 'Enter') {
+          event.preventDefault();
+          openFor();
+        }
+      };
+      item.tabIndex = 0;
+      item.addEventListener('keydown', onKey);
+      item.appendChild(button);
+      cleanups.push(() => {
+        button.removeEventListener('click', openFor);
+        item.removeEventListener('keydown', onKey);
+        button.remove();
+        item.removeAttribute('tabindex');
+      });
+    });
+    return () => cleanups.forEach((cleanup) => cleanup());
+  }, [mode, text, doc]);
+
   if (!doc) {
     return <ViewState state="empty" />;
   }
diff --git a/apps/console/src/views/MentionsSection.tsx b/apps/console/src/views/MentionsSection.tsx
new file mode 100644
index 00000000..08cbf6c0
--- /dev/null
+++ b/apps/console/src/views/MentionsSection.tsx
@@ -0,0 +1,215 @@
+'use client';
+
+// SOURCING: @commonplace/block-view (host query/emit; candidates are objects
+// on the seam). The Mentions section (HANDOFF-CARDS-ACTIONS-MENTIONS K6):
+// mounts on cards and the inspector, reading "mentioned in N places, M
+// unlinked," expanding to the passages with confirm and dismiss per row.
+// Linking is computed and evidenced, never silent (named choice 6): confirm
+// patches the candidate to confirmed and the engine writes the identity edge
+// with the recorded basis; dismiss records the negative signal. An object
+// with no candidates shows no mentions chrome at all.
+
+import { useCallback, useEffect, useState } from 'react';
+import type { BlockHost, ObjectRef } from '@commonplace/block-view/types';
+
+// The seam's canonical type refs are dash-form: commonplace-api's
+// normalize_type_ref rewrites underscores to dashes on every wire query.
+export const MENTION_CANDIDATE_TYPE = 'mention-candidate';
+
+export interface MentionCandidate {
+  readonly id: string;
+  readonly objectId: string;
+  readonly atomId: string;
+  readonly matchedAlias: string;
+  readonly tier: string;
+  readonly status: 'unlinked' | 'confirmed' | 'dismissed';
+  /** The passage around the match, captured at detection time so the surface
+   *  never re-fetches atom text. */
+  readonly snippet: string;
+  /** Offsets of the matched alias within `snippet`. */
+  readonly snippetStart: number;
+  readonly snippetEnd: number;
+}
+
+function candidateFromRef(ref: ObjectRef): MentionCandidate | null {
+  const props = ref.properties;
+  const objectId = props.object_id;
+  const atomId = props.atom_id;
+  const alias = props.matched_alias;
+  if (typeof objectId !== 'string' || typeof atomId !== 'string' || typeof alias !== 'string') {
+    return null;
+  }
+  const status = props.status === 'confirmed' || props.status === 'dismissed' ? props.status : 'unlinked';
+  const snippet = typeof props.snippet === 'string' ? props.snippet : '';
+  const start = typeof props.snippet_start === 'number' ? props.snippet_start : 0;
+  const end = typeof props.snippet_end === 'number' ? props.snippet_end : 0;
+  return {
+    id: ref.id,
+    objectId,
+    atomId,
+    matchedAlias: alias,
+    tier: typeof props.tier === 'string' ? props.tier : 'exact',
+    status,
+    snippet,
+    snippetStart: Math.max(0, Math.min(start, snippet.length)),
+    snippetEnd: Math.max(0, Math.min(end, snippet.length)),
+  };
+}
+
+export function useMentionCandidates(host: BlockHost, objectId: string) {
+  const [candidates, setCandidates] = useState<readonly MentionCandidate[]>([]);
+  const [generation, setGeneration] = useState(0);
+  const refresh = useCallback(() => setGeneration((value) => value + 1), []);
+
+  useEffect(() => {
+    let active = true;
+    let retryTimer: ReturnType<typeof setTimeout> | undefined;
+    const load = (attempt: number) => {
+      Promise.resolve(
+        host.query({
+          types: [MENTION_CANDIDATE_TYPE],
+          where: { kind: 'eq', field: 'object_id', value: objectId },
+          page: { limit: 200 },
+        }),
+      )
+        .then((set) => {
+          if (!active) return;
+          setCandidates(
+            set.objects
+              .map(candidateFromRef)
+              .filter(
+                (entry): entry is MentionCandidate => entry !== null && entry.objectId === objectId,
+              ),
+          );
+        })
+        .catch(() => {
+          // One bounded retry before settling on the no-chrome state, so a
+          // transient wire hiccup does not permanently hide real candidates.
+          if (!active) return;
+          if (attempt === 0) {
+            retryTimer = setTimeout(() => load(1), 1000);
+            return;
+          }
+          setCandidates([]);
+        });
+    };
+    load(0);
+    return () => {
+      active = false;
+      if (retryTimer) clearTimeout(retryTimer);
+    };
+  }, [host, objectId, generation]);
+
+  return { candidates, refresh };
+}
+
+function Passage({ candidate }: { candidate: MentionCandidate }) {
+  const { snippet, snippetStart, snippetEnd } = candidate;
+  if (!snippet) return <span className="text-ij-ink-info">{candidate.matchedAlias}</span>;
+  const before = snippet.slice(0, snippetStart);
+  const match = snippet.slice(snippetStart, snippetEnd);
+  const after = snippet.slice(snippetEnd);
+  return (
+    <span className="text-ij-ink-info">
+      {before}
+      <mark data-mention-span className="bg-ij-selection text-ij-ink">
+        {match || candidate.matchedAlias}
+      </mark>
+      {after}
+    </span>
+  );
+}
+
+/** The Mentions section body: mounts under the card facts (K1 children slot)
+ *  and in the inspector. Renders nothing at all without candidates. */
+export function MentionsSection({ host, object }: { host: BlockHost; object: ObjectRef }) {
+  const { candidates, refresh } = useMentionCandidates(host, object.id);
+  const [expanded, setExpanded] = useState(false);
+  const [pending, setPending] = useState<string | null>(null);
+
+  const linked = candidates.filter((entry) => entry.status === 'confirmed');
+  const unlinked = candidates.filter((entry) => entry.status === 'unlinked');
+  if (linked.length === 0 && unlinked.length === 0) return null;
+
+  const setStatus = async (candidate: MentionCandidate, status: 'confirmed' | 'dismissed') => {
+    setPending(candidate.id);
+    await host.emit({ kind: 'update', id: candidate.id, patch: { status } });
+    setPending(null);
+    refresh();
+  };
+
+  return (
+    <section data-mentions-section className="border-t border-ij-divider p-rec-cell-pad">
+      <button
+        type="button"
+        aria-expanded={expanded}
+        onClick={() => setExpanded((value) => !value)}
+        className="flex w-full items-baseline gap-2 text-left text-ij-ink hover:text-ij-accent focus:outline-2 focus:outline-ij-accent"
+        style={{ transition: 'var(--rec-clickable-transition)' }}
+      >
+        <span style={{ fontWeight: 'var(--rec-weight-medium)' }}>Mentions</span>
+        <span className="text-ij-ink-info" data-mentions-summary>
+          mentioned in {candidates.length - candidates.filter((c) => c.status === 'dismissed').length}{' '}
+          places, {unlinked.length} unlinked
+        </span>
+      </button>
+      {expanded ? (
+        <ul className="mt-1">
+          {[...unlinked, ...linked].map((candidate) => (
+            <li
+              key={candidate.id}
+              data-mention-candidate={candidate.status}
+              className="border-b border-ij-divider py-rec-grid last:border-b-0"
+            >
+              <Passage candidate={candidate} />
+              <div className="mt-1 flex items-center gap-2">
+                <span className="font-ij-mono text-ij-ink-disabled">{candidate.tier}</span>
+                {candidate.status === 'unlinked' ? (
+                  <>
+                    <button
+                      type="button"
+                      disabled={pending === candidate.id}
+                      onClick={() => setStatus(candidate, 'confirmed')}
+                      className="h-6 rounded-ij-arc border border-ij-control-border bg-ij-editor px-2 text-ij-ink hover:bg-ij-hover-surface focus:outline-2 focus:outline-ij-accent"
+                      style={{ transition: 'var(--rec-clickable-transition)' }}
+                    >
+                      Confirm
+                    </button>
+                    <button
+                      type="button"
+                      disabled={pending === candidate.id}
+                      onClick={() => setStatus(candidate, 'dismissed')}
+                      className="h-6 rounded-ij-arc px-2 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink focus:outline-2 focus:outline-ij-accent"
+                      style={{ transition: 'var(--rec-clickable-transition)' }}
+                    >
+                      Dismiss
+                    </button>
+                  </>
+                ) : (
+                  <span className="text-ij-ink-info">linked</span>
+                )}
+              </div>
+            </li>
+          ))}
+        </ul>
+      ) : null}
+    </section>
+  );
+}
+
+/** The card-header chip: a small unlinked-total marker when candidates exist
+ *  (K6). Renders nothing at zero. */
+export function UnlinkedMentionsChip({ host, object }: { host: BlockHost; object: ObjectRef }) {
+  const { candidates } = useMentionCandidates(host, object.id);
+  const unlinked = candidates.filter((entry) => entry.status === 'unlinked').length;
+  if (unlinked === 0) return null;
+  return (
+    <span
+      data-mentions-chip
+      className="ml-auto inline-flex h-5 shrink-0 items-center rounded-ij-arc-underline bg-ij-editor px-2 font-ij-mono text-ij-accent"
+      aria-label={`${unlinked} unlinked mentions`}
+    >
+      {unlinked}
+    </span>
+  );
+}
diff --git a/apps/console/src/views/RecordInspector.tsx b/apps/console/src/views/RecordInspector.tsx
index 4594cde0..a7f62798 100644
--- a/apps/console/src/views/RecordInspector.tsx
+++ b/apps/console/src/views/RecordInspector.tsx
@@ -3,17 +3,30 @@
 // SOURCING: @commonplace/block-view (host query/emit). The record.inspector
 // descriptor (G6): a 500px right tool window (--rec-side-panel) that opens on
 // selection and closes without stealing focus. Structure at Twenty metrics,
-// paint from the Int UI register.
+// paint from the Int UI register. K2: the inspector leads with the object's
+// compact card above the raw field table; relation chips there navigate the
+// inspector to the related object.
 
 import { useCallback, useEffect, useState } from 'react';
 import type { BlockHost, ObjectRef } from '@commonplace/block-view/types';
-import { useShellStore } from '@/lib/shell-store';
+import { objectChip, useShellStore } from '@/lib/shell-store';
+import { RecordCard } from './CardView';
 import { ViewState } from './ViewStates';
 
 export function RecordInspector({ host }: { host: BlockHost }) {
   const selectedRecordId = useShellStore((state) => state.selectedRecordId);
+  const selectedRecordObject = useShellStore((state) => state.selectedRecordObject);
+  const selectedTypeHint = useShellStore((state) => state.selectedTypeHint);
   const selectRecord = useShellStore((state) => state.selectRecord);
-  const [record, setRecord] = useState<ObjectRef | null>(null);
+  const openActionSheet = useShellStore((state) => state.openActionSheet);
+  const [fetched, setFetched] = useState<ObjectRef | null>(null);
+  // The opener may have handed us the object (a grid cell, a chip with a
+  // resolved target); deriving at render time keeps the effect fetch-only
+  // (no sync setState in effects, the react-hooks v6 rule).
+  const record =
+    selectedRecordObject && selectedRecordObject.id === selectedRecordId
+      ? selectedRecordObject
+      : fetched;
 
   // Closing returns focus to the stream row that opened the inspector (R4
   // punch list). The row may have virtualized away; the record scroller is
@@ -31,9 +44,21 @@ export function RecordInspector({ host }: { host: BlockHost }) {
 
   useEffect(() => {
     let active = true;
-    if (!selectedRecordId) return;
+    // A stashed object needs no wire: the render derives it directly, and
+    // the effect stays fetch-only (no sync setState in effects).
+    if (
+      !selectedRecordId ||
+      (selectedRecordObject && selectedRecordObject.id === selectedRecordId)
+    ) {
+      return;
+    }
+    // Cross-kind fetch: a chip's target kind rides along as the hint; the
+    // record wire stays the default so table selections resolve as before.
+    const types = selectedTypeHint && selectedTypeHint !== 'record'
+      ? [selectedTypeHint, 'record']
+      : ['record'];
     Promise.resolve(
-      host.query({ types: ['record'], where: { kind: 'eq', field: 'id', value: selectedRecordId } }),
+      host.query({ types, where: { kind: 'eq', field: 'id', value: selectedRecordId } }),
     ).then((set) => {
       if (!active) return;
       // The fixture host filters on properties; fall back to scanning by id.
@@ -41,17 +66,17 @@ export function RecordInspector({ host }: { host: BlockHost }) {
         set.objects.find((object) => object.id === selectedRecordId) ??
         null;
       if (match) {
-        setRecord(match);
+        setFetched(match);
         return;
       }
-      Promise.resolve(host.query({ types: ['record'] })).then((all) => {
-        if (active) setRecord(all.objects.find((object) => object.id === selectedRecordId) ?? null);
+      Promise.resolve(host.query({ types })).then((all) => {
+        if (active) setFetched(all.objects.find((object) => object.id === selectedRecordId) ?? null);
       });
     });
     return () => {
       active = false;
     };
-  }, [host, selectedRecordId]);
+  }, [host, selectedRecordId, selectedRecordObject, selectedTypeHint]);
 
   if (!selectedRecordId) return null;
 
@@ -71,6 +96,29 @@ export function RecordInspector({ host }: { host: BlockHost }) {
         <span className="text-ij-ink" style={{ fontWeight: 'var(--rec-weight-cap)' }}>
           Inspector
         </span>
+        {record ? (
+          <button
+            type="button"
+            data-inspector-action
+            onClick={() =>
+              // The Action verb on the inspector (K3): same sheet, this
+              // object pre-staged as the originating chip.
+              openActionSheet({
+                chips: [
+                  objectChip(
+                    record.id,
+                    record.type,
+                    String(record.properties.title ?? record.id),
+                  ),
+                ],
+              })
+            }
+            className="ml-auto h-6 rounded-ij-arc border border-ij-control-border bg-ij-editor px-2 text-ij-ink-info hover:bg-ij-hover-surface hover:text-ij-ink focus:outline-2 focus:outline-ij-accent"
+            style={{ transition: 'var(--rec-clickable-transition)' }}
+          >
+            Action
+          </button>
+        ) : null}
         <button
           type="button"
           onClick={close}
@@ -82,19 +130,24 @@ export function RecordInspector({ host }: { host: BlockHost }) {
         </button>
       </div>
       {record && record.id === selectedRecordId ? (
-        <dl className="min-h-0 flex-1 overflow-y-auto p-4">
-          {Object.entries(record.properties).map(([key, value]) => (
-            <div key={key} className="mb-rec-grid border-b border-ij-divider pb-rec-grid">
-              <dt className="text-ij-ink-info" style={{ fontWeight: 'var(--rec-weight-medium)' }}>
-                {key}
-              </dt>
-              <dd className="text-ij-ink">
-                {Array.isArray(value) ? value.join(', ') : String(value)}
-              </dd>
-            </div>
-          ))}
-          <div className="mt-2 font-ij-mono text-ij-ink-disabled">{record.id}</div>
-        </dl>
+        <div className="min-h-0 flex-1 overflow-y-auto">
+          <div className="border-b border-ij-seam p-3" data-inspector-card>
+            <RecordCard object={record} host={host} size="compact" />
+          </div>
+          <dl className="p-4">
+            {Object.entries(record.properties).map(([key, value]) => (
+              <div key={key} className="mb-rec-grid border-b border-ij-divider pb-rec-grid">
+                <dt className="text-ij-ink-info" style={{ fontWeight: 'var(--rec-weight-medium)' }}>
+                  {key}
+                </dt>
+                <dd className="text-ij-ink">
+                  {Array.isArray(value) ? value.join(', ') : String(value)}
+                </dd>
+              </div>
+            ))}
+            <div className="mt-2 font-ij-mono text-ij-ink-disabled">{record.id}</div>
+          </dl>
+        </div>
       ) : (
         <ViewState state="loading" />
       )}
diff --git a/apps/console/src/views/ThreadView.tsx b/apps/console/src/views/ThreadView.tsx
index 8d4e443f..30e88fac 100644
--- a/apps/console/src/views/ThreadView.tsx
+++ b/apps/console/src/views/ThreadView.tsx
@@ -71,6 +71,8 @@ export function ThreadView() {
   const runtimeAvailable = useContext(ThreadRuntimeAvailable);
   const isRunning = useThreadStore((state) => state.isRunning);
   const error = useThreadStore((state) => state.error);
+  const staged = useThreadStore((state) => state.staged);
+  const unstage = useThreadStore((state) => state.unstage);
   const endpoint = chatEndpoint();
 
   if (!runtimeAvailable) {
@@ -109,9 +111,33 @@ export function ThreadView() {
         ) : null}
         {error ? <div className="px-4 py-1 text-ij-error">{error}</div> : null}
       </ThreadPrimitive.Viewport>
+      {staged.length > 0 ? (
+        // With-me staging (K4): object references ride visibly above the
+        // composer and travel with the next message; removable until sent.
+        <div className="flex flex-wrap items-center gap-1 border-t border-ij-seam px-2 pt-2" data-thread-staged>
+          {staged.map((ref) => (
+            <span
+              key={ref.id}
+              data-thread-staged-ref
+              className="inline-flex h-6 items-center gap-1 rounded-ij-arc border border-ij-control-border bg-ij-editor px-2 text-ij-ink"
+            >
+              <span className="max-w-48 truncate">{ref.label}</span>
+              <button
+                type="button"
+                aria-label={`Remove ${ref.label}`}
+                onClick={() => unstage(ref.id)}
+                className="text-ij-ink-info hover:text-ij-ink"
+              >
+                ×
+              </button>
+            </span>
+          ))}
+        </div>
+      ) : null}
       <ComposerPrimitive.Root className="flex shrink-0 items-end gap-2 border-t border-ij-seam p-2">
         <ComposerPrimitive.Input
           rows={1}
+          data-thread-composer-input
           placeholder="Message the harness"
           className="max-h-40 min-h-ij-control flex-1 resize-none rounded-ij-arc border border-ij-control-border bg-ij-editor px-3 py-1 text-ij-ink placeholder:text-ij-ink-disabled focus:outline-2 focus:outline-ij-accent"
         />
diff --git a/apps/console/src/views/registry.tsx b/apps/console/src/views/registry.tsx
index 6b93ea49..5b7b9c69 100644
--- a/apps/console/src/views/registry.tsx
+++ b/apps/console/src/views/registry.tsx
@@ -12,6 +12,7 @@ import { GalleyDocView } from './GalleyDocView';
 import { CodeFileView } from './CodeFileView';
 import { ThreadView } from './ThreadView';
 import { DocListView, IndexRailView } from './DocListView';
+import { CardFullView, CardGridView } from './CardView';
 import { HunkReviewView } from './HunkReviewView';
 
 function ThreadRender(_props: ViewRenderProps) {
@@ -108,6 +109,40 @@ const INDEX_RAIL: ViewDescriptor = {
   render: IndexRailView,
 };
 
+// The card engine descriptor family (HANDOFF-CARDS-ACTIONS-MENTIONS K1):
+// one engine renders any kind's template. card.full mounts in panes and
+// documents; cards.grid renders an ObjectQuery as faces at Twenty density.
+const CARD_FULL: ViewDescriptor = {
+  id: 'card.full',
+  name: 'Card',
+  accepts: {},
+  emits: ['select', 'open'],
+  renderer: 'card.full',
+  source: {
+    package: '@commonplace/block-view',
+    component: 'BlockHost',
+    mode: 'bespoke',
+    regime: 'css-vars',
+    allowedBespokeReason: 'kind-templated card layouts are a domain concept no library models',
+  },
+  render: CardFullView,
+};
+
+const CARDS_GRID: ViewDescriptor = {
+  id: 'cards.grid',
+  name: 'Cards',
+  accepts: {},
+  emits: ['select', 'open'],
+  renderer: 'cards.grid',
+  source: {
+    package: '@tanstack/react-virtual',
+    component: 'useVirtualizer',
+    mode: 'wrap',
+    regime: 'css-vars',
+  },
+  render: CardGridView,
+};
+
 const HUNK_REVIEW: ViewDescriptor = {
   id: 'hunk.review',
   name: 'Review',
@@ -131,6 +166,8 @@ export const CONSOLE_VIEW_REGISTRY = createViewRegistry([
   CHAT_THREAD,
   DOC_LIST,
   INDEX_RAIL,
+  CARD_FULL,
+  CARDS_GRID,
   HUNK_REVIEW,
 ]);
 
diff --git a/crates/commonplace/src/block_view.rs b/crates/commonplace/src/block_view.rs
index 36b730d3..9fea81d6 100644
--- a/crates/commonplace/src/block_view.rs
+++ b/crates/commonplace/src/block_view.rs
@@ -928,6 +928,9 @@ where
             ObjectAction::Create { type_ref, props } => {
                 let item = item_from_props(&type_ref, props)?;
                 let item = self.put_item(item)?;
+                // Incremental mention detection (K5): a new text-bearing item
+                // is an atom; evaluate it once, never a full rescan.
+                self.evaluate_mentions_for_atom(&item.id)?;
                 Ok(ObjectActionReceipt {
                     action_kind,
                     status: ObjectActionStatus::Applied,
@@ -947,6 +950,19 @@ where
                 })?;
                 apply_item_patch(&mut item, patch)?;
                 let item = self.put_item(item)?;
+                if item_object_type_slug(&item) == crate::mentions::MENTION_CANDIDATE_KIND {
+                    // The confirm hook (K6): patching a candidate to
+                    // confirmed writes the identity edge with its basis; a
+                    // dismissal needs no extra write (the candidate is the
+                    // negative signal and the suppression record).
+                    if item.status.as_deref() == Some("confirmed") {
+                        self.apply_mention_confirmation(&item)?;
+                    }
+                } else {
+                    // An edited atom re-evaluates incrementally; existing
+                    // candidate ids (any status) stay untouched.
+                    self.evaluate_mentions_for_atom(&item.id)?;
+                }
                 Ok(ObjectActionReceipt {
                     action_kind,
                     status: ObjectActionStatus::Applied,
diff --git a/crates/commonplace/src/ingest.rs b/crates/commonplace/src/ingest.rs
index d49bc0fa..fec5b73f 100644
--- a/crates/commonplace/src/ingest.rs
+++ b/crates/commonplace/src/ingest.rs
@@ -690,6 +690,10 @@ where
         let similar_items =
             self.write_similarity_edges(commonplace, &item.id, prior_items.as_slice(), &embedding)?;
         let entities = self.resolve_entities(commonplace, &item.id, &searchable_text)?;
+        // Incremental mention detection (HANDOFF-CARDS-ACTIONS-MENTIONS K5):
+        // the freshly ingested item is a new atom; evaluate it once, in the
+        // same seam the entity resolver rides. Never a full rescan.
+        commonplace.evaluate_mentions_for_atom(&item.id)?;
         prior_items.push(item.clone());
 
         Ok(IngestReceipt {
diff --git a/crates/commonplace/src/lib.rs b/crates/commonplace/src/lib.rs
index ae4ce90b..c2a99fa0 100644
--- a/crates/commonplace/src/lib.rs
+++ b/crates/commonplace/src/lib.rs
@@ -29,6 +29,7 @@ pub mod collection;
 pub mod content_core;
 pub mod ingest;
 pub mod item;
+pub mod mentions;
 pub mod organize;
 pub mod page;
 pub mod reconstruction;
diff --git a/crates/commonplace/src/mentions.rs b/crates/commonplace/src/mentions.rs
new file mode 100644
index 00000000..d3ea2614
--- /dev/null
+++ b/crates/commonplace/src/mentions.rs
@@ -0,0 +1,529 @@
+//! Unlinked-mention detection (HANDOFF-CARDS-ACTIONS-MENTIONS K5/K6).
+//!
+//! Unlinked mentions are identity-edge candidates, and the reconstruction
+//! guardrail is the spine: detection proposes, a person confirms, and the
+//! confirmed edge records its basis (matched alias, atom, span). Nothing
+//! auto-links.
+//!
+//! The pass matches object titles and aliases against atom text on two tiers,
+//! exact and normalized-exact (the semantic tier is explicitly out of this
+//! round). It runs incrementally on new or edited atoms (mirroring the
+//! `resolve_entities` seam in ingest), never as a full rescan. Candidates are
+//! plain items of kind `mention-candidate`, so they ride the object seam like
+//! anything else; their deterministic id keys (object, atom, alias), which is
+//! also the suppression record: a dismissed candidate never reappears on
+//! re-evaluation because the id already exists.
+//!
+//! Normalization for the second tier: casefold plus punctuation stripped to
+//! spaces, whitespace collapsed. The recorded span always slices the ORIGINAL
+//! atom text back to the matched alias.
+
+use serde_json::{json, Map, Value};
+
+use rustyred_thg_core::{EdgeRecord, GraphStore, GraphStoreError, GraphStoreResult};
+
+use crate::blob::BlobStore;
+use crate::item::{Item, ItemBody, ItemKind};
+use crate::renderable::item_object_type_slug;
+use crate::store::Commonplace;
+
+/// The candidate kind on the object seam.
+pub const MENTION_CANDIDATE_KIND: &str = "mention-candidate";
+/// The identity edge a confirmation writes: object MENTIONED_IN atom.
+pub const MENTIONED_IN_EDGE: &str = "MENTIONED_IN";
+
+/// Kinds that never act as mention targets or atoms: seam metadata.
+const META_KINDS: [&str; 2] = [MENTION_CANDIDATE_KIND, "card-template"];
+/// Aliases shorter than this are noise, not identity.
+const MIN_ALIAS_LEN: usize = 3;
+/// Snippet window on each side of the match, in characters.
+const SNIPPET_CONTEXT: usize = 60;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct MentionMatch {
+    pub object_id: String,
+    pub atom_id: String,
+    pub matched_alias: String,
+    /// "exact" or "normalized".
+    pub tier: &'static str,
+    /// Char offsets into the atom's original text.
+    pub span_start: usize,
+    pub span_end: usize,
+    pub snippet: String,
+    /// Char offsets of the match within `snippet`.
+    pub snippet_start: usize,
+    pub snippet_end: usize,
+}
+
+/// The deterministic candidate id: also the dedup and suppression key.
+pub fn mention_candidate_id(object_id: &str, atom_id: &str, alias: &str) -> String {
+    format!("mention:{object_id}:{atom_id}:{}", alias_slug(alias))
+}
+
+fn alias_slug(alias: &str) -> String {
+    let mut out = String::with_capacity(alias.len());
+    for ch in alias.chars() {
+        if ch.is_alphanumeric() {
+            out.extend(ch.to_lowercase());
+        } else if !out.ends_with('-') {
+            out.push('-');
+        }
+    }
+    out.trim_matches('-').to_string()
+}
+
+/// The text a detection pass scans: the atom's inline body. Blob and empty
+/// bodies carry no scannable text in this round.
+fn atom_text(item: &Item) -> Option<&str> {
+    match &item.body {
+        ItemBody::Inline { text } if !text.trim().is_empty() => Some(text),
+        _ => None,
+    }
+}
+
+/// The aliases an object is known by: its title plus any `aliases` string
+/// list in `extra`. (No kind carries a dedicated alias field today; the
+/// `aliases` property is the convention this pass reads.)
+fn aliases_of(item: &Item) -> Vec<String> {
+    let mut aliases = Vec::new();
+    let title = item.title.trim();
+    if title.chars().count() >= MIN_ALIAS_LEN {
+        aliases.push(title.to_string());
+    }
+    if let Some(Value::Array(values)) = item.extra.get("aliases") {
+        for value in values {
+            if let Some(text) = value.as_str() {
+                let text = text.trim();
+                if text.chars().count() >= MIN_ALIAS_LEN && !aliases.iter().any(|a| a == text) {
+                    aliases.push(text.to_string());
+                }
+            }
+        }
+    }
+    aliases
+}
+
+fn is_word_char(ch: char) -> bool {
+    ch.is_alphanumeric()
+}
+
+/// Exact-tier find: the alias as a substring on word boundaries. Returns char
+/// offsets into `text`.
+fn find_exact(text: &str, alias: &str) -> Option<(usize, usize)> {
+    let text_chars: Vec<char> = text.chars().collect();
+    let alias_chars: Vec<char> = alias.chars().collect();
+    if alias_chars.is_empty() || alias_chars.len() > text_chars.len() {
+        return None;
+    }
+    for start in 0..=(text_chars.len() - alias_chars.len()) {
+        if text_chars[start..start + alias_chars.len()] != alias_chars[..] {
+            continue;
+        }
+        let boundary_before = start == 0 || !is_word_char(text_chars[start - 1]);
+        let end = start + alias_chars.len();
+        let boundary_after = end == text_chars.len() || !is_word_char(text_chars[end]);
+        if boundary_before && boundary_after {
+            return Some((start, end));
+        }
+    }
+    None
+}
+
+/// Normalized view of a string: casefolded, punctuation as spaces, whitespace
+/// collapsed. Each normalized char carries the char offset of its source in
+/// the original, so a normalized match maps back to an original span.
+fn normalized_view(text: &str) -> (Vec<char>, Vec<usize>) {
+    let mut chars = Vec::new();
+    let mut map = Vec::new();
+    let mut last_space = true;
+    for (index, ch) in text.chars().enumerate() {
+        if ch.is_alphanumeric() {
+            for lowered in ch.to_lowercase() {
+                chars.push(lowered);
+                map.push(index);
+            }
+            last_space = false;
+        } else if !last_space {
+            chars.push(' ');
+            map.push(index);
+            last_space = true;
+        }
+    }
+    (chars, map)
+}
+
+/// Normalized-tier find: match in normalized space, span in original chars.
+fn find_normalized(text: &str, alias: &str) -> Option<(usize, usize)> {
+    let (text_norm, map) = normalized_view(text);
+    let (alias_norm, _) = normalized_view(alias);
+    let alias_norm: Vec<char> = alias_norm
+        .iter()
+        .copied()
+        .skip_while(|c| *c == ' ')
+        .collect();
+    let alias_trimmed: Vec<char> = alias_norm
+        .iter()
+        .rev()
+        .copied()
+        .skip_while(|c| *c == ' ')
+        .collect::<Vec<_>>()
+        .into_iter()
+        .rev()
+        .collect();
+    if alias_trimmed.is_empty() || alias_trimmed.len() > text_norm.len() {
+        return None;
+    }
+    for start in 0..=(text_norm.len() - alias_trimmed.len()) {
+        if text_norm[start..start + alias_trimmed.len()] != alias_trimmed[..] {
+            continue;
+        }
+        let boundary_before = start == 0 || text_norm[start - 1] == ' ';
+        let end = start + alias_trimmed.len();
+        let boundary_after = end == text_norm.len() || text_norm[end] == ' ';
+        if boundary_before && boundary_after {
+            let orig_start = map[start];
+            let orig_end = map[end - 1] + 1;
+            return Some((orig_start, orig_end));
+        }
+    }
+    None
+}
+
+fn snippet_around(text: &str, span_start: usize, span_end: usize) -> (String, usize, usize) {
+    let chars: Vec<char> = text.chars().collect();
+    let start = span_start.saturating_sub(SNIPPET_CONTEXT);
+    let end = (span_end + SNIPPET_CONTEXT).min(chars.len());
+    let snippet: String = chars[start..end].iter().collect();
+    (snippet, span_start - start, span_end - start)
+}
+
+/// Match one target's aliases against one atom's text. Exact tier wins per
+/// alias; the normalized tier fires only when exact found nothing.
+pub fn match_aliases(object_id: &str, atom_id: &str, text: &str, aliases: &[String]) -> Vec<MentionMatch> {
+    let mut matches = Vec::new();
+    for alias in aliases {
+        let found = find_exact(text, alias)
+            .map(|span| (span, "exact"))
+            .or_else(|| find_normalized(text, alias).map(|span| (span, "normalized")));
+        if let Some(((span_start, span_end), tier)) = found {
+            let (snippet, snippet_start, snippet_end) = snippet_around(text, span_start, span_end);
+            matches.push(MentionMatch {
+                object_id: object_id.to_string(),
+                atom_id: atom_id.to_string(),
+                matched_alias: alias.clone(),
+                tier,
+                span_start,
+                span_end,
+                snippet,
+                snippet_start,
+                snippet_end,
+            });
+        }
+    }
+    matches
+}
+
+fn candidate_item(m: &MentionMatch) -> Item {
+    let mut extra = Map::new();
+    extra.insert("object_id".into(), Value::String(m.object_id.clone()));
+    extra.insert("atom_id".into(), Value::String(m.atom_id.clone()));
+    extra.insert("matched_alias".into(), Value::String(m.matched_alias.clone()));
+    extra.insert("tier".into(), Value::String(m.tier.to_string()));
+    extra.insert("span_start".into(), json!(m.span_start));
+    extra.insert("span_end".into(), json!(m.span_end));
+    extra.insert("snippet".into(), Value::String(m.snippet.clone()));
+    extra.insert("snippet_start".into(), json!(m.snippet_start));
+    extra.insert("snippet_end".into(), json!(m.snippet_end));
+    let mut item = Item::new(
+        ItemKind::Other(MENTION_CANDIDATE_KIND.to_string()),
+        format!("{} in {}", m.matched_alias, m.atom_id),
+    );
+    item.id = mention_candidate_id(&m.object_id, &m.atom_id, &m.matched_alias);
+    // Status rides the item's indexed scalar (the same slot tasks use), so a
+    // wire patch of `status` lands where filters and the projection read it.
+    item.status = Some("unlinked".to_string());
+    item.extra = extra;
+    item
+}
+
+impl<S, B> Commonplace<S, B>
+where
+    S: GraphStore,
+    B: BlobStore,
+{
+    /// Incremental detection for one atom (a new or edited text-bearing
+    /// item): every other object's title and aliases are matched against the
+    /// atom's text, and fresh candidates are filed. Existing candidate ids
+    /// (unlinked, confirmed, or dismissed) are left untouched, which is what
+    /// keeps dismissals suppressed across re-evaluation.
+    pub fn evaluate_mentions_for_atom(&mut self, atom_id: &str) -> GraphStoreResult<Vec<Item>> {
+        let Some(atom) = self.get_item(atom_id)? else {
+            return Ok(Vec::new());
+        };
+        if META_KINDS.contains(&item_object_type_slug(&atom).as_str()) {
+            return Ok(Vec::new());
+        }
+        let Some(text) = atom_text(&atom).map(str::to_string) else {
+            return Ok(Vec::new());
+        };
+        let targets: Vec<(String, Vec<String>)> = self
+            .all_items()?
+            .into_iter()
+            .filter(|item| item.id != atom_id)
+            .filter(|item| !META_KINDS.contains(&item_object_type_slug(item).as_str()))
+            .map(|item| {
+                let aliases = aliases_of(&item);
+                (item.id, aliases)
+            })
+            .filter(|(_, aliases)| !aliases.is_empty())
+            .collect();
+
+        let mut created = Vec::new();
+        for (object_id, aliases) in targets {
+            for m in match_aliases(&object_id, atom_id, &text, &aliases) {
+                let id = mention_candidate_id(&m.object_id, &m.atom_id, &m.matched_alias);
+                if self.get_item(&id)?.is_some() {
+                    continue;
+                }
+                let stored = self.put_item(candidate_item(&m))?;
+                created.push(stored);
+            }
+        }
+        Ok(created)
+    }
+
+    /// The confirm hook (K6): when a `mention_candidate` is patched to
+    /// `status: confirmed`, write the identity edge with the basis recorded
+    /// on the edge itself (matched alias, atom, span, snippet). Dismissal
+    /// needs no extra write: the candidate item is the negative signal.
+    pub fn apply_mention_confirmation(&mut self, candidate: &Item) -> GraphStoreResult<()> {
+        let get = |key: &str| -> GraphStoreResult<String> {
+            candidate
+                .extra
+                .get(key)
+                .and_then(Value::as_str)
+                .map(str::to_string)
+                .ok_or_else(|| {
+                    GraphStoreError::new(
+                        "mention_candidate_incomplete",
+                        format!("candidate {} is missing {key}", candidate.id),
+                    )
+                })
+        };
+        let object_id = get("object_id")?;
+        let atom_id = get("atom_id")?;
+        let basis = json!({
+            "basis": {
+                "matched_alias": candidate.extra.get("matched_alias").cloned().unwrap_or(Value::Null),
+                "atom_id": atom_id,
+                "span_start": candidate.extra.get("span_start").cloned().unwrap_or(Value::Null),
+                "span_end": candidate.extra.get("span_end").cloned().unwrap_or(Value::Null),
+                "snippet": candidate.extra.get("snippet").cloned().unwrap_or(Value::Null),
+                "tier": candidate.extra.get("tier").cloned().unwrap_or(Value::Null),
+                "candidate_id": candidate.id,
+            }
+        });
+        let edge = EdgeRecord::new(
+            format!("mentioned-in:{object_id}:{atom_id}"),
+            object_id.as_str(),
+            MENTIONED_IN_EDGE,
+            atom_id.as_str(),
+            basis,
+        )
+        .with_confidence(1.0);
+        self.store_mut().upsert_edge(edge)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn exact_match_respects_word_boundaries() {
+        assert_eq!(find_exact("met Ada Lovelace today", "Ada Lovelace"), Some((4, 16)));
+        assert_eq!(find_exact("metAda Lovelace today", "Ada"), None);
+        assert_eq!(find_exact("Ada.", "Ada"), Some((0, 3)));
+    }
+
+    #[test]
+    fn normalized_match_maps_back_to_the_original_span() {
+        let text = "Talked to A. Lovelace about the engine.";
+        let span = find_normalized(text, "a lovelace").expect("normalized hit");
+        let original: String = text.chars().skip(span.0).take(span.1 - span.0).collect();
+        assert_eq!(original, "A. Lovelace");
+    }
+
+    #[test]
+    fn snippet_slices_back_to_the_alias() {
+        let text = "x".repeat(100) + " Ada Lovelace " + &"y".repeat(100);
+        let matches = match_aliases("person:ada", "note:1", &text, &[String::from("Ada Lovelace")]);
+        assert_eq!(matches.len(), 1);
+        let m = &matches[0];
+        let sliced: String = m
+            .snippet
+            .chars()
+            .skip(m.snippet_start)
+            .take(m.snippet_end - m.snippet_start)
+            .collect();
+        assert_eq!(sliced, "Ada Lovelace");
+        let original: String = text.chars().skip(m.span_start).take(m.span_end - m.span_start).collect();
+        assert_eq!(original, "Ada Lovelace");
+    }
+
+    #[test]
+    fn exact_tier_wins_over_normalized() {
+        let matches = match_aliases("p", "a", "Ada Lovelace wrote notes", &[String::from("Ada Lovelace")]);
+        assert_eq!(matches[0].tier, "exact");
+    }
+
+    use crate::block_view::{ObjectAction, ObjectQuery};
+    use crate::InMemoryBlobStore;
+    use rustyred_thg_core::InMemoryGraphStore;
+
+    fn fresh() -> Commonplace<InMemoryGraphStore, InMemoryBlobStore> {
+        Commonplace::new(InMemoryGraphStore::new(), InMemoryBlobStore::new())
+    }
+
+    fn create(
+        cp: &mut Commonplace<InMemoryGraphStore, InMemoryBlobStore>,
+        type_ref: &str,
+        props: Value,
+    ) -> String {
+        let props = match props {
+            Value::Object(map) => map,
+            _ => panic!("props must be an object"),
+        };
+        let receipt = cp
+            .emit_object_action(
+                ObjectAction::Create {
+                    type_ref: type_ref.to_string(),
+                    props,
+                },
+                None,
+            )
+            .expect("create applies");
+        receipt.target_ids[0].clone()
+    }
+
+    fn candidates_for(
+        cp: &Commonplace<InMemoryGraphStore, InMemoryBlobStore>,
+        object_id: &str,
+    ) -> Vec<Item> {
+        let set = cp
+            .query_object_set(ObjectQuery::new([MENTION_CANDIDATE_KIND]))
+            .expect("candidate query");
+        set.objects
+            .into_iter()
+            .filter(|obj| {
+                obj.properties.get("object_id").and_then(Value::as_str) == Some(object_id)
+            })
+            .filter_map(|obj| cp.get_item(&obj.id).ok().flatten())
+            .collect()
+    }
+
+    /// The K5/K6 round trip: seeded aliases yield candidates whose spans
+    /// slice the atom text back to the alias; a new matching atom produces
+    /// its candidate within one evaluation cycle; nothing auto-creates an
+    /// edge; confirmation writes the identity edge with an inspectable
+    /// basis; dismissal suppresses the pair across re-evaluation.
+    #[test]
+    fn candidate_to_confirmed_edge_round_trip() {
+        let mut cp = fresh();
+        let person_id = create(
+            &mut cp,
+            "person",
+            json!({ "title": "Ada Lovelace", "aliases": ["Countess of Lovelace"] }),
+        );
+
+        let atom_1 = create(
+            &mut cp,
+            "note",
+            json!({ "title": "n1", "body": "Met Ada Lovelace at the engine works." }),
+        );
+        create(
+            &mut cp,
+            "note",
+            json!({ "title": "n2", "body": "The Countess of Lovelace annotated the memoir." }),
+        );
+        create(
+            &mut cp,
+            "note",
+            json!({ "title": "n3", "body": "ada lovelace, again, in lowercase." }),
+        );
+
+        let found = candidates_for(&cp, &person_id);
+        assert_eq!(found.len(), 3, "three atoms, one candidate each");
+        for candidate in &found {
+            let snippet = candidate.extra["snippet"].as_str().unwrap();
+            let start = candidate.extra["snippet_start"].as_u64().unwrap() as usize;
+            let end = candidate.extra["snippet_end"].as_u64().unwrap() as usize;
+            let sliced: String = snippet.chars().skip(start).take(end - start).collect();
+            let alias = candidate.extra["matched_alias"].as_str().unwrap();
+            assert!(
+                sliced.eq_ignore_ascii_case(alias) || sliced.contains(alias),
+                "span slices back to the alias: {sliced:?} vs {alias:?}"
+            );
+            assert_eq!(candidate.status.as_deref(), Some("unlinked"));
+        }
+
+        // No candidate auto-creates an edge.
+        let edge_id = format!("mentioned-in:{person_id}:{atom_1}");
+        assert!(cp.store().get_edge(&edge_id).is_none());
+
+        // A new matching atom produces its candidate within one cycle.
+        create(&mut cp, "note", json!({ "title": "n4", "body": "Ada Lovelace, once more." }));
+        assert_eq!(candidates_for(&cp, &person_id).len(), 4);
+
+        // Confirm the first candidate: the edge exists and its basis is
+        // inspectable from the edge itself.
+        let first = found
+            .iter()
+            .find(|c| c.extra["atom_id"] == json!(atom_1.clone()))
+            .expect("candidate for atom 1");
+        cp.emit_object_action(
+            ObjectAction::Update {
+                id: first.id.clone(),
+                patch: Map::from_iter([("status".to_string(), json!("confirmed"))]),
+            },
+            None,
+        )
+        .expect("confirm applies");
+        let edge = cp.store().get_edge(&edge_id).expect("identity edge written");
+        assert_eq!(edge.properties["basis"]["matched_alias"], json!("Ada Lovelace"));
+        assert_eq!(edge.properties["basis"]["atom_id"], json!(atom_1));
+        assert!(edge.properties["basis"]["span_start"].is_number());
+
+        // Dismiss another candidate, then edit its atom: the pair does not
+        // reappear and the dismissal is preserved.
+        let dismissed = candidates_for(&cp, &person_id)
+            .into_iter()
+            .find(|c| c.status.as_deref() == Some("unlinked"))
+            .expect("an unlinked candidate remains");
+        let dismissed_atom = dismissed.extra["atom_id"].as_str().unwrap().to_string();
+        cp.emit_object_action(
+            ObjectAction::Update {
+                id: dismissed.id.clone(),
+                patch: Map::from_iter([("status".to_string(), json!("dismissed"))]),
+            },
+            None,
+        )
+        .expect("dismiss applies");
+        cp.emit_object_action(
+            ObjectAction::Update {
+                id: dismissed_atom.clone(),
+                patch: Map::from_iter([("title".to_string(), json!("edited title"))]),
+            },
+            None,
+        )
+        .expect("atom edit applies");
+        let after = cp.get_item(&dismissed.id).expect("read").expect("exists");
+        assert_eq!(after.status.as_deref(), Some("dismissed"), "dismissal survives re-evaluation");
+        assert_eq!(
+            candidates_for(&cp, &person_id).len(),
+            4,
+            "re-evaluation creates no duplicate for the dismissed pair"
+        );
+    }
+}