Address greybeard review: accurate docs, seeded task visibility, drop the string task shape

- docs/TUI.md: the subscribeChrome paragraph claimed making it required fixed
  an observed break; the production caller always passed it, so restate this
  as closing a shape that could have type-checked while omitted, not a fix
  for something that broke.
- docs/TUI.md: the collapse-order paragraph conflated two mechanisms.
  COLLAPSE_ORDER/collapseOnce governs what collapse takes from zones ahead of
  prompt; PROMPT_CAP_FRACTION independently bounds the prompt's own requested
  height before collapse ever runs. Name both and what each guarantees.
- shell.ts defaultVisibility: seed task: 0 alongside agents: 0, so the
  adjacent comment about avoiding a needless first relayout is true for both
  row-count fields it now describes.
- chrome-state.ts: delete the string member of ChromeLiveState['task'] and
  formatTasksPanel's string branch. chromeFromSession never produces a
  string, so the only callers left were its own tests — a back-compat
  surface for callers this repo owns, which AGENTS.md forbids. Updated
  demo.ts and the tests that exercised the string shape accordingly.
- Reworded 'session-persisted' to 'shell-lifetime, in memory, nothing
  written to storage' everywhere it appeared (docs, comments, a test title)
  — that is the actual design, the phrasing just claimed durability it
  doesn't have.
- geometry.test.ts: corrected a test comment that attributed the short-
  terminal invariant solely to collapse order; across most of the tested
  range it actually holds via PROMPT_CAP_FRACTION capping the requested
  prompt before collapse runs at all.

Author: TheGreatAxios

docs/TUI.md

@@ -116,26 +116,39 @@ bounded to `TASKS_PANEL_MAX_VISIBLE` rows, same shape as the agents panel: a
 longer list degrades to a trailing `+N more` row rather than growing the zone
 without limit, and it shrinks one row at a time under space pressure
 (`COLLAPSE_ORDER` in `geometry/zones.ts`) rather than vanishing in one step.
-`task` sits ahead of `agents` in `COLLAPSE_ORDER`, so on a short terminal the
-task panel is always fully collapsed before the prompt box is ever touched —
-the prompt is never pushed off screen by a competing chrome zone.
+
+Two independent mechanisms keep the task panel from ever costing the prompt
+box a row on a short terminal, and they guarantee different things.
+`COLLAPSE_ORDER` places `task` ahead of `prompt`, so `collapseOnce`
+(`geometry/resolve.ts`) always drains `task` to zero before it ever reduces
+`prompt` — that loop only runs when the transcript floor is not yet met, and
+it never touches a zone later in the order while an earlier one still has
+rows to give up. Separately, `PROMPT_CAP_FRACTION` in `desiredHeights` caps
+how tall a *requested* prompt is allowed to start at (`PROMPT_CAP_FRACTION *
+terminal.rows`), independent of collapse and before it ever runs. Neither
+mechanism substitutes for the other: the cap bounds the prompt's own growth
+on any terminal, tall or short; the collapse order bounds what other zones
+are allowed to take from it once the transcript floor is at risk.
 
 The panel is toggleable independent of its live data: `toggleTasksPanel`
-(bound to the `toggle_task` palette action) flips a hidden flag that persists
-on the shell for the life of the session, while the live task list keeps
-updating underneath it — un-hiding shows the current list, not a stale
-snapshot from before the hide. Hidden or empty, the zone costs zero rows.
+(bound to the `toggle_task` palette action) flips a hidden flag held on the
+shell for its lifetime — in memory only, nothing written to storage — while
+the live task list keeps updating underneath it. Un-hiding shows the current
+list, not a stale snapshot from before the hide. Hidden or empty, the zone
+costs zero rows.
 
 The task tool writes state through `ChatDirectorImpl` (`src/agent/director.ts`),
 which calls `onTasksChange` on every `manage_tasks` tool call and on session
 resume (`restoreTasks`). The runner forwards that into the OpenTUI host via
 `RunnerHostDeps.chrome`/`subscribeChrome` (`src/tui-opentui/runner-host.ts`):
-`subscribeChrome` is a required dependency, not optional, because an omitted
-subscription used to type-check cleanly while silently leaving the panel
-frozen at its mount-time snapshot — a mechanism built and never wired, hidden
-behind an optional callback. `runner-host.test.ts` drives a live
-`subscribeChrome` notify end to end and asserts the panel actually repaints,
-so that class of regression fails a test again if it recurs.
+`subscribeChrome` is a required dependency, not optional. The production
+caller has always passed a real subscription, so this did not fix an
+observed break; it closes a shape that could have been omitted and would
+still have type-checked — the same "callback that types fine when absent"
+hazard this feature's own callback (`onTasksChange`) is named after in the
+tracking issue. `runner-host.test.ts` drives a live `subscribeChrome` notify
+end to end and asserts the panel actually repaints, so an omission would now
+fail a test as well as the type checker.
 
 ## The live agents panel
 

src/tui-opentui/chrome-state.test.ts

@@ -28,9 +28,11 @@ describe("formatChromeZones", () => {
     })
   })
 
-  test("partial: task string only", () => {
-    const out = formatChromeZones({ task: "cutover readiness" })
-    expect(out.task).toEqual([{ label: "cutover readiness", status: null }])
+  test("partial: task rows only", () => {
+    const out = formatChromeZones({
+      task: [{ title: "cutover readiness", status: "doing" }],
+    })
+    expect(out.task).toEqual([{ label: "cutover readiness", status: "doing" }])
     expect(out.agents).toBeNull()
   })
 
@@ -100,13 +102,9 @@ describe("formatChromeZones", () => {
 })
 
 describe("formatTasksPanel", () => {
-  test("string / empty", () => {
+  test("null / undefined hide the zone", () => {
     expect(formatTasksPanel(null)).toBeNull()
-    expect(formatTasksPanel("")).toBeNull()
-    expect(formatTasksPanel("  ")).toBeNull()
-    expect(formatTasksPanel("wire host")).toEqual([
-      { label: "wire host", status: null },
-    ])
+    expect(formatTasksPanel(undefined)).toBeNull()
   })
 
   test("each row carries its own status", () => {

src/tui-opentui/chrome-state.ts

@@ -61,11 +61,10 @@ export type TaskPanelRow = {
  */
 export type ChromeLiveState = {
   /**
-   * Task list: string shorthand (rendered as a single unstyled row) or the
-   * structured rows the task tool writes. Distinct from `agents` — a task is
-   * a unit of work with a status, not an executor.
+   * Task list: the structured rows the task tool writes. Distinct from
+   * `agents` — a task is a unit of work with a status, not an executor.
    */
-  readonly task?: readonly ChromeTaskRow[] | string | null
+  readonly task?: readonly ChromeTaskRow[] | null
   /** Subagent sessions for the strip summary (running preferred). */
   readonly agents?: readonly ChromeAgentSession[] | null
   /**
@@ -131,20 +130,14 @@ export function chromeZonesContent(state: ChromeLiveState): ChromeZoneContent {
  *
  * Terminal tasks (done/cancelled) still render — the panel is a live list of
  * work, not just what remains — so an operator watching it sees a task move
- * to "done" rather than silently vanish. A bare string input renders as one
- * row with no status marker: it is free-form summary text, not a task record.
+ * to "done" rather than silently vanish.
  */
 export function formatTasksPanel(
-  task: readonly ChromeTaskRow[] | string | null | undefined,
+  task: readonly ChromeTaskRow[] | null | undefined,
   maxVisible: number = TASKS_PANEL_MAX_VISIBLE,
 ): readonly TaskPanelRow[] | null {
   if (task === null || task === undefined) return null
 
-  if (typeof task === "string") {
-    const t = task.trim()
-    return t.length === 0 ? null : [{ label: t, status: null }]
-  }
-
   const rows: TaskPanelRow[] = task
     .map((t) => ({ label: t.title.trim(), status: t.status }))
     .filter((r) => r.label.length > 0)

src/tui-opentui/demo.ts

@@ -277,7 +277,9 @@ renderer.keyInput.on("keypress", (key: KeyEvent) => {
     setChromeZones(shell, {
       task: on
         ? null
-        : formatChromeZones({ task: "cutover readiness" }).task,
+        : formatChromeZones({
+            task: [{ title: "cutover readiness", status: "doing" }],
+          }).task,
     })
     return
   }

src/tui-opentui/geometry.test.ts

@@ -190,10 +190,16 @@ describe("resolveGeometry — task panel", () => {
   });
 
   test("on a short terminal the task panel is fully collapsed before the prompt is ever shrunk below its idle rows", () => {
-    // Shrink the terminal until something has to give. The task panel sits
-    // ahead of the prompt in COLLAPSE_ORDER, so collapseOnce always drains it
-    // to zero before touching the prompt — the prompt degrades last, never
-    // first, so it is never pushed off screen by a competing chrome zone.
+    // Shrink the terminal until something has to give. Two mechanisms can
+    // land the prompt below its idle rows here: PROMPT_CAP_FRACTION caps the
+    // *requested* prompt before collapse ever runs (the one that actually
+    // fires across most of this range, since a short terminal caps prompt
+    // rows well before a 6-row task panel could account for the deficit on
+    // its own), and collapseOnce would additionally shrink prompt only after
+    // draining every zone ahead of it in COLLAPSE_ORDER — task included.
+    // Either way the invariant holds: whenever prompt is below its idle
+    // rows, task is already at zero, so the task panel never survives at
+    // the prompt's expense.
     for (let rows = 24; rows >= 10; rows--) {
       const layout = resolveGeometry({
         terminal: { columns: 80, rows },

src/tui-opentui/shell.ts

@@ -761,9 +761,10 @@ function defaultVisibility(visibility?: ZoneVisibility): ZoneVisibility {
     notice: false,
     progress: false,
     progressDivider: false,
-    // Explicit 0 rather than left undefined: the agents field is now a row
-    // count, and setChromeZones compares it by ===, so an undefined start
-    // forces one needless relayout the first time it is ever compared.
+    // Explicit 0 rather than left undefined: task and agents are row
+    // counts, and setChromeZones compares them by ===, so an undefined
+    // start forces one needless relayout the first time either is compared.
+    task: 0,
     agents: 0,
     ...visibility,
   }
@@ -1895,7 +1896,7 @@ type ShellInternals = {
     /** Agents panel rows (empty array = zone off), one row per rendered line. */
     agents: readonly AgentPanelRow[]
   }
-  /** Operator toggle for the task panel; persists for the life of the shell (session). */
+  /** Operator toggle for the task panel; in-memory, held for the life of the shell. */
   tasksPanelHidden: boolean
 }
 
@@ -4341,7 +4342,8 @@ export function setChromeZones(
  * Toggle the task-list panel visible/hidden without touching the live task
  * data underneath it — un-hiding shows whatever the task tool last wrote,
  * not a stale snapshot from before the hide. The flag lives on the shell's
- * internals for the life of the process, i.e. persists for the session.
+ * internals in memory for the shell's lifetime; nothing is written to
+ * storage, so it does not survive a restart.
  */
 export function toggleTasksPanel(shell: AppShell): void {
   const bag = internals.get(shell)

src/tui-opentui/wave6.test.ts

@@ -566,7 +566,7 @@ describe("CL-5731: task list panel", () => {
     )
   })
 
-  test("the toggle persists across further chrome pushes for the life of the shell (the session)", async () => {
+  test("the toggle persists across further chrome pushes for the life of the shell", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {