Drop the bare ? shortcut-list binding, move the version to its own row

? was the only bare, unmodified punctuation key bound anywhere in the
shell, and it shadowed a character an operator might genuinely want to
type at the prompt. Remove the binding and its SHELL_SHORTCUTS row; the
shortcut list itself stays reachable as /help, which the command registry
already exposed.

Move the running build version out of the landing screen's hero block
(where it sat beside the mark and the two doors) into its own row pinned
to the terminal's last line, right-aligned, distinct from landing.ts's
composition. It only borrows that row while the landing screen is
showing — a session's transcript content gets it back — and hides itself
on a narrow or short terminal well before any other actionable chrome
would need to shrink.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -210,7 +210,7 @@ Profiles with `orchestrator: true` may themselves call `task` (one hop only): ne
 
 **Session records** (`src/subagent/session-store.ts`): each spawn is retained as an inspectable child session (id, profile, description, brief, status, tool activity, transcript entries). Child events land only in this store — not in the parent chat transcript. Live progress still uses the light `onProgress` channel for the status bar. Completed sessions are capped (`maxCompleted`) so a long chat does not grow without bound.
 
-**Observe (OpenTUI)**: the command palette's **observe** action (`src/tui-opentui/palette.ts`) asks the host for a live session (`onObserveRequest` → `observeSessionFromSubAgents`, `src/tui-opentui/runner-host.ts`), which picks the newest running child, else the most recent session of any status. Entering observe swaps the transcript for that child's stream (live while running, historical when done) without stealing the parent reactor; child events are mapped to stream rows by `src/tui-opentui/observe-map.ts`. Esc leaves observe and restores the parent transcript. Parent Esc/stop and `/clear` still call `cancelAll` so live children close (`agent.close`) instead of continuing after the parent stops.
+**Observe (OpenTUI)**: `shell.ts:enterSubagentObserve` swaps the transcript for a child's stream (live while running, historical when done) without stealing the parent reactor; child events are mapped to stream rows by `src/tui-opentui/observe-map.ts`. Esc leaves observe and restores the parent transcript. Parent Esc/stop and `/clear` still call `cancelAll` so live children close (`agent.close`) instead of continuing after the parent stops. The host-injection point that resolves a live session (`onObserveRequest` → `observeSessionFromSubAgents`, `src/tui-opentui/runner-host.ts`, picking the newest running child else the most recent session of any status) remains wired up, but nothing in the product currently triggers it — the command palette action that used to call it is gone (removed along with `palette.ts`).
 
 Data-only agent plugins (`src/plugins/data-only-agent.ts`) synthesize `agentPlugin.agents[]` from `agents/*.md` or flat `*.md` in the plugin directory, with optional co-located `skills/`. `loadPluginEntry` tries JS entrypoints first, then falls back to this layout (`/plugins` add-by-path supports filesystem completion via `listPathSuggestions`).
 

docs/TUI.md

@@ -143,7 +143,7 @@ same last-resort floor every other optional zone shares.
 ## How pop-ups should feel
 
 A blocking surface (permissions, an operator question, the model/provider
-picker, settings, help, the command palette, …) shares one overlay host and
+picker, settings, help, the `/` command list, …) shares one overlay host and
 one height path — there is no second modal stack with independent row
 accounting (`src/tui-opentui/geometry/resolve.ts`,
 `src/tui-opentui/shell.ts:openListOverlay`). Opening a second surface either
@@ -181,7 +181,7 @@ rather than a background fill.
 ## How selectors should work
 
 Every list surface — permissions, the operator question, the model picker,
-the command palette, resume/session-mode pickers, settings — shares one list
+the `/` command list, resume/session-mode pickers, settings — shares one list
 viewport kit: shared windowing, keep-active-visible, and page/jump behavior.
 There is exactly one scroll lease at a time; keyboard paging and the mouse
 wheel both follow whichever surface currently holds it, so a modal open on
@@ -217,6 +217,23 @@ overlay this reuses is still internally called `"palette"` (`shell.ts`'s
 also opened it; that chord is gone (see keybindings.ts), and the identifier
 stayed because renaming an internal overlay tag has no user-facing effect.
 
+`?` no longer binds anything — it is a literal character everywhere, prompt
+or transcript. The shortcut list it used to open is still reachable, as
+`/help` (`src/tui/commands/built-in.ts`, routed to `shell.ts:openHelpOverlay`
+via `openCommandSurface`'s `"help"` case, `command-surfaces.ts`); the `/` row
+in `SHELL_SHORTCUTS` documents that in place of a dedicated `?` row.
+
+The running build version is chrome, not part of the landing composition:
+`shell.ts`'s `versionRow`/`versionBadge`, a dedicated row pinned to the
+terminal's last line and right-aligned, distinct from `landing.ts`'s hero and
+below sections. It only reserves that row while the landing screen is
+showing (`relayout`'s `versionReserved`/`terminalForGeometry`) — once there
+is real transcript content the row goes back to whatever needed it, and the
+badge stops rendering. On a narrow or short terminal it hides
+(`versionBadgeVisible`, thresholds `VERSION_BADGE_MIN_COLUMNS`/
+`VERSION_BADGE_MIN_ROWS` in `landing.ts`) well before the prompt box or any
+other actionable chrome would need to shrink.
+
 The model/provider picker is provider-first
 (`src/tui-opentui/product-host.ts:groupModelsForPicker`/`openLevel`): recent
 and favorite provider+model pairs stay flat at the top of the list (already

src/tui-opentui/keybindings.test.ts

@@ -20,11 +20,13 @@ import { PROMPT_KEY_BINDINGS } from "./prompt-input.js"
 import { SHELL_SHORTCUTS } from "./keybindings.js"
 import { createHarness, withTestRenderer, type Harness } from "./harness.js"
 import { mountRunnerHost } from "./runner-host.js"
+import { openCommandSurface } from "./command-surfaces.js"
 import { focusOwner } from "./focus/focus-state.js"
 import {
   appendStreamRow,
   createAppShell,
   isSlashPopupOpen,
+  openHelpOverlay,
   setMentionSuggestionSource,
   setPaletteCatalog,
   setPromptImageSource,
@@ -336,24 +338,6 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
       shell.prompt.value = ""
     },
   },
-  "?": {
-    group: "surfaces",
-    probe: ({ h, shell, chords }) => {
-      shellFocusPrompt(shell)
-      shell.prompt.value = ""
-      press(h, chords[0])
-      // The condition, not just the chord: at the prompt it is a character.
-      expect(shell.overlayKind).toBeNull()
-
-      shellFocusTranscript(shell)
-      press(h, chords[0])
-      expect(shell.overlayKind).toBe("help")
-      press(h, chords[0])
-      expect(shell.overlayKind).toBeNull()
-      shellFocusPrompt(shell)
-      shell.prompt.value = ""
-    },
-  },
   "@": {
     group: "surfaces",
     probe: async ({ h, shell, chords }) => {
@@ -678,3 +662,73 @@ describe("the runner host does not shadow the prompt bindings the catalog claims
   })
 })
 
+describe("? no longer opens help", () => {
+  test("bare ? types a literal character instead of opening the shortcut list", async () => {
+    const harness = await createHarness({ width: 80, height: 24 })
+    try {
+      const shell = createAppShell(harness.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        wireKeys: true,
+        run: "idle",
+      })
+      try {
+        shellFocusPrompt(shell)
+        shell.prompt.value = ""
+        harness.pressKey("?")
+        expect(shell.overlayKind).toBeNull()
+        expect(shell.prompt.value).toBe("?")
+
+        shellFocusTranscript(shell)
+        harness.pressKey("?")
+        // No binding claims it with the transcript focused either — help has
+        // no chord left at all, only the /help command.
+        expect(shell.overlayKind).toBeNull()
+      } finally {
+        shell.dispose()
+      }
+    } finally {
+      harness.destroy()
+    }
+  })
+})
+
+describe("help stays reachable as a command", () => {
+  test("/help still opens the shortcut list", async () => {
+    const notifications: string[] = []
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        run: "idle",
+      })
+      try {
+        expect(shell.overlayKind).toBeNull()
+        const opened = openCommandSurface(shell, "help", {
+          notify: (text) => notifications.push(text),
+        })
+        expect(opened).toBe(true)
+        expect(shell.overlayKind).toBe("help")
+      } finally {
+        shell.dispose()
+      }
+    })
+  })
+
+  test("openHelpOverlay (the /help handler) opens the same overlay the removed ? chord used to", async () => {
+    const harness = await createHarness({ width: 80, height: 24 })
+    try {
+      const shell = createAppShell(harness.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        run: "idle",
+      })
+      try {
+        openHelpOverlay(shell)
+        expect(shell.overlayKind).toBe("help")
+      } finally {
+        shell.dispose()
+      }
+    } finally {
+      harness.destroy()
+    }
+  })
+})
+

src/tui-opentui/keybindings.ts

@@ -39,9 +39,8 @@ export const SHELL_SHORTCUTS: readonly ShellShortcut[] = [
   { keys: "Ctrl+Y", description: "yank the last kill at the cursor" },
   { keys: "Alt+Y", description: "replace the text just yanked with the next-older kill" },
   { keys: "Ctrl+V / Ctrl+P", description: "attach an image from the clipboard to the next message" },
-  { keys: "?", description: "with the transcript focused, open this shortcut list; press again to close it" },
   { keys: "@", description: "at the start of a word, open file suggestions for the @mention being typed" },
-  { keys: "/", description: "at an empty prompt, open the command list (Tab completes, Enter runs)" },
+  { keys: "/", description: "at an empty prompt, open the command list (Tab completes, Enter runs); also lists /help" },
   { keys: "Up / Down", description: "recall previously sent messages, from the prompt's first / last row" },
   { keys: "Arrow keys", description: "move the cursor left / right / up / down in the prompt" },
   {

src/tui-opentui/landing.test.ts

@@ -29,6 +29,9 @@ import {
   landingSuggestionFor,
   resolveMarkGrid,
   splitLandingRows,
+  VERSION_BADGE_MIN_COLUMNS,
+  VERSION_BADGE_MIN_ROWS,
+  versionBadgeVisible,
   wrapLanding,
 } from "./landing"
 import { LOCKUP_WORDMARK } from "./lockup"
@@ -106,7 +109,10 @@ describe("landing layout math", () => {
     expect(resolveMarkGrid(12, 96)).toBe(MARK_MID)
     expect(resolveMarkGrid(9, 96)).toBe(MARK_SMALL)
     // Narrow enough that the mark would crowd the hints: the hints win.
-    expect(resolveMarkGrid(20, 50)).toBe(MARK_SMALL)
+    // (The version moved off this hint block into the shell's own chrome —
+    // CL-5736 — so the block is narrower and a bit more room stays for the
+    // mark at this width than before.)
+    expect(resolveMarkGrid(20, 50)).toBe(MARK_MID)
     expect(resolveMarkGrid(20, 30)).toBeNull()
     expect(resolveMarkGrid(3, 96)).toBeNull()
   })
@@ -161,9 +167,20 @@ describe("landing screen", () => {
           descriptionColumns.add(row!.indexOf(hint.rest))
         }
         expect(descriptionColumns.size).toBe(1)
-        // The version sits with the hints, and cannot drift from package.json.
+        // The version is chrome, not part of the hero: it never shares a row
+        // with a hint, and cannot drift from package.json.
         expect(LANDING_VERSION).toBe(`v${pkg.version}`)
-        expect(h.captureCharFrame()).toContain(LANDING_VERSION)
+        for (const hint of LANDING_HINTS) {
+          const row = painted.find((line) => line.includes(hint.rest))
+          expect(row).not.toContain(LANDING_VERSION)
+        }
+        const versionRow = painted.findIndex((row) => row.includes(LANDING_VERSION))
+        expect(versionRow).toBeGreaterThanOrEqual(0)
+        // Bottom-right: on the terminal's last content row, hugging the right
+        // edge rather than sitting under the hints.
+        expect(versionRow).toBeGreaterThanOrEqual(SIZE.height - 2)
+        const versionCol = painted[versionRow]!.lastIndexOf(LANDING_VERSION)
+        expect(versionCol + LANDING_VERSION.length).toBeGreaterThan(SIZE.width - 4)
         const noticeRow = painted.findIndex((row) => row.includes("telemetry"))
         expect(noticeRow).toBeGreaterThan(bottom)
         for (const item of LANDING_SUGGESTIONS) {
@@ -306,7 +323,9 @@ describe("landing screen", () => {
         const ruleRow = painted.findIndex((row) =>
           row.includes(LOCKUP_WORDMARK),
         )
-        // The prompt box rests on the terminal's last row.
+        // Session-active: the version row only reserves space on the landing
+        // screen (see `relayout`), so once there is real transcript content
+        // the box is back on the terminal's very last row.
         expect(ruleRow).toBe(SIZE.height - 1)
         const row = painted[ruleRow]!
         // Left end of the rule, inside the shell gutter, costing no row.
@@ -605,4 +624,103 @@ describe("landing screen", () => {
       }
     }, SIZE)
   })
+
+  test("the version is chrome, not the hero: it hides before actionable chrome does on a narrow terminal", async () => {
+    // Comfortably above the badge's own thresholds but below nothing else —
+    // proves the badge is what degrades, and degrades first.
+    const roomy = { width: VERSION_BADGE_MIN_COLUMNS + 20, height: VERSION_BADGE_MIN_ROWS + 8 }
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: roomy.width, rows: roomy.height },
+          wireKeys: false,
+          run: "idle",
+        })
+        try {
+          await settle(h)
+          expect(h.captureCharFrame()).toContain(LANDING_VERSION)
+        } finally {
+          shell.dispose()
+        }
+      },
+      roomy,
+    )
+
+    // Just under the badge's column floor: the badge is gone, but the prompt
+    // field — genuinely actionable chrome — is still on screen.
+    const narrowColumns = {
+      width: VERSION_BADGE_MIN_COLUMNS - 1,
+      height: VERSION_BADGE_MIN_ROWS + 8,
+    }
+    expect(versionBadgeVisible(narrowColumns.width, narrowColumns.height)).toBe(false)
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: narrowColumns.width, rows: narrowColumns.height },
+          wireKeys: false,
+          run: "idle",
+        })
+        try {
+          await settle(h)
+          const frame = h.captureCharFrame()
+          expect(frame).not.toContain(LANDING_VERSION)
+          expect(frame).toContain("message")
+        } finally {
+          shell.dispose()
+        }
+      },
+      narrowColumns,
+    )
+
+    // Just under the badge's row floor: same story, short rather than narrow.
+    const shortRows = {
+      width: VERSION_BADGE_MIN_COLUMNS + 20,
+      height: VERSION_BADGE_MIN_ROWS - 1,
+    }
+    expect(versionBadgeVisible(shortRows.width, shortRows.height)).toBe(false)
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: shortRows.width, rows: shortRows.height },
+          wireKeys: false,
+          run: "idle",
+        })
+        try {
+          await settle(h)
+          const frame = h.captureCharFrame()
+          expect(frame).not.toContain(LANDING_VERSION)
+          expect(frame).toContain("message")
+        } finally {
+          shell.dispose()
+        }
+      },
+      shortRows,
+    )
+  })
+
+  test("the version never appears inside the hero block beside the mark/hints", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: SIZE.width, rows: SIZE.height },
+          wireKeys: false,
+          run: "idle",
+        })
+        try {
+          await settle(h)
+          const painted = rows(h)
+          const heroEnd = painted.findIndex((row) => /[┌╭]/.test(row))
+          expect(heroEnd).toBeGreaterThan(0)
+          // Nothing above the box's own top border carries the version — the
+          // hero (mark + hint doors) is exactly the two lines, no third.
+          for (const row of painted.slice(0, heroEnd)) {
+            expect(row).not.toContain(LANDING_VERSION)
+          }
+        } finally {
+          shell.dispose()
+        }
+      },
+      SIZE,
+    )
+  })
 })