Stop restating settled permission prompts in the chat

Author: TheGreatAxios

CHANGELOG.md

@@ -11,6 +11,18 @@ matching `## [X.Y.Z]` section (plus install instructions). Do not maintain
 parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 `## [Unreleased]` to `## [X.Y.Z] - YYYY-MM-DD`, then run the release script.
 
+## [Unreleased]
+
+### TUI
+
+- **Settled permission and operator prompts no longer recap into the chat.**
+  The overlay is the question; answering it used to leave a grey
+  `permission` / `operator` card restating the same command and the chosen
+  option. After a decision those recap rows are gone — the tool row that
+  follows is the outcome. Expanding a collapsed payload while the overlay is
+  still open still writes the full payload into the transcript, because that
+  text would otherwise be unreachable before approval.
+
 ## [0.2.98] - 2026-08-17
 
 Corrupt resume state no longer kills sessions, Codex quota errors name the

docs/TUI.md

@@ -138,28 +138,20 @@ removed line), not a decision marker, and no decision-marker shares that row.
 
 ## The live task list panel
 
-The `task` chrome zone renders a standing panel in the bottom chrome above the
-prompt, one row per open task the task tool has written (`manage_tasks`) —
-distinct from live sub-agent progress. A task is a unit of work with a status;
-an agent is an executor with its own context and transcript. They are never
-merged into one panel: `formatTasksPanel` (`src/tui/chrome-state.ts`) feeds the
-checklist zone; live workers paint as `● Task …` transcript rows (see below).
-
-**One live surface at a time.** While any sub-agent session is `running`,
-`formatChromeZones` suppresses the task checklist and keeps the agents zone
-empty — the same work must not stand as a FLEET board *and* a checklist *and*
-live Task rows. When no lane is running, the checklist returns for open work
-(if the operator has opted in with Alt+T). A list that is only done/cancelled
-collapses to null (no permanent wall of `[x]` rows); while open work remains,
-recently-done rows trail so the operator can see items flip complete without a
-second status log.
-
-Each row shows a bracket status marker (`[ ]` todo, `[~]` doing, `[x]` done,
-`[-]` cancelled) ahead of the title. Open work is listed first. The panel is
-bounded to `TASKS_PANEL_MAX_VISIBLE` rows: 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.
+**Parked pending rebuild.** `formatChromeZones` (`src/tui/chrome-state.ts`)
+always returns `{ task: null, agents: null }` — neither the checklist strip nor
+the agents/fleet board auto-paints. Live work stays on transcript `● Task …`
+rows (see below). `formatTasksPanel` / `formatAgentsPanel` remain for a future
+rebuild; demos and shell tests may still feed preformatted rows via
+`setChromeZones` directly, and Alt+T (`toggleTasksPanel`) still toggles the
+shell's hidden flag for those manual paints.
+
+A task is a unit of work with a status; an agent is an executor with its own
+context and transcript. They are never merged into one panel. When the
+checklist strip is rebuilt, each row will show a bracket status marker (`[ ]`
+todo, `[~]` doing, `[x]` done, `[-]` cancelled) ahead of the title, bounded to
+`TASKS_PANEL_MAX_VISIBLE` with a trailing `+N more` under overflow, and
+shrinking via `COLLAPSE_ORDER` in `geometry/zones.ts`.
 
 Two independent mechanisms keep the task panel from ever costing the prompt
 box a row on a short terminal, and they guarantee different things.
@@ -174,20 +166,17 @@ 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 **hidden by default** (CL-5847): a fresh shell does not paint the
-checklist even when `manage_tasks` has open work. `toggleTasksPanel` (bound to
-Alt+T) opts in for the shell's lifetime — it flips a hidden flag held on the
-shell 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
-default is opt-in because the checklist's chrome owns too much of the screen to
-force into view; the operator toggles it on when they want it, and live Task
-rows still win while a fleet is running.
+The panel stays **hidden by default** (CL-5847): a fresh shell does not paint
+the checklist. `toggleTasksPanel` (bound to Alt+T) opts in for the shell's
+lifetime — it flips a hidden flag held on the shell in memory only — so demos
+and tests that call `setChromeZones` with task rows can still show them.
+Because `formatChromeZones` parks auto-paint, Alt+T alone does not surface a
+live `manage_tasks` list today.
 
 The task tool writes state through `ChatDirectorImpl` (`src/agent/director.ts`),
 which calls `onTasksChange` on every `manage_tasks` tool call and on session
-hydrate. `manage_tasks` calls paint no transcript rows — the checklist is the
-only surface for that list.
+hydrate. `manage_tasks` calls paint no transcript rows; with chrome strips
+parked, that list has no standing chrome surface until rebuild.
 
 ## Live sub-agent rows (Task tool)
 
@@ -202,8 +191,10 @@ operator-preferred Amp/Codex-style lines:
 `runtime-bridge` paints each `task` call as a stream row and rewrites it in
 place via `syncAgentProgress` / `agentProgress` (elapsed clock, current tool,
 stall marker). There is no standing FLEET board and no dual-rail agents chrome:
-`formatChromeZones` always returns `agents: null`, and geometry is stack-only
-(`layoutMode: "stack"`, `railWidth: 0`).
+`formatChromeZones` always returns both zones null (`task` and `agents`), and
+geometry is stack-only (`layoutMode: "stack"`, `railWidth: 0`). Checklist and
+agents strips are parked pending rebuild; Alt+T / direct `setChromeZones` may
+still paint for demos and tests.
 
 ### Unprompted fleet reports
 
@@ -251,6 +242,16 @@ because an earlier version could abandon the awaited promise on Escape and
 leave the session parked with no recovery path short of killing the process;
 Escape must always settle the promise it is dismissing.
 
+Once a permission or operator prompt is answered — or cancelled, timed out,
+or auto-settled by a grant / abort / teardown — it leaves the screen and
+does **not** replay the request, the command, or the chosen option into the
+transcript. The overlay is the question; the tool row that follows is the
+outcome. Grey `permission` / `operator` recap cards restated the same ask
+after it was already decided. Expanding a collapsed payload while the
+overlay is open still writes the full payload into the scrollable
+transcript, because that text would otherwise be unreachable before
+approval.
+
 The decision surfaces (permission approval, operator question) are the one
 framed content in the shell, and they are shaped rather than merely listed
 (`src/tui/overlay-body.ts`): a dithered header (`░▒▓`) carries the

src/tui/gate-wire.test.ts

@@ -384,7 +384,7 @@ describe("wireGates", () => {
     })
   })
 
-  test("gate content reaches the transcript only after the operator decides", async () => {
+  test("gate decisions do not replay the request into the transcript", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 96, rows: 30 },
@@ -401,20 +401,15 @@ describe("wireGates", () => {
         const dispose = wireGates(emitter, shell)
         emitter.emit("permission.gate", { request, resolve: () => {} })
 
-        // The overlay is showing this text; a transcript copy directly above it
-        // reads as a second, unrelated request.
         expect(
           shell.streamLog.filter((r) => r.meta === "permission"),
         ).toHaveLength(0)
 
         acceptOverlaySelection(shell)
 
-        const recorded = shell.streamLog
-          .filter((r) => r.meta === "permission")
-          .map((r) => r.text)
-          .join("\n")
-        expect(recorded).toContain("ls -la ~/.corbits/projects")
-        expect(recorded).toContain("Reject")
+        expect(
+          shell.streamLog.filter((r) => r.meta === "permission"),
+        ).toHaveLength(0)
 
         dispose()
       } finally {
@@ -424,7 +419,7 @@ describe("wireGates", () => {
   })
 })
 
-describe("each gate decision appends exactly one transcript row", () => {
+describe("gate decisions stay out of the transcript", () => {
   test("permission accept", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
@@ -438,7 +433,7 @@ describe("each gate decision appends exactly one transcript row", () => {
 
         const before = shell.streamLog.length
         acceptOverlaySelection(shell)
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -458,7 +453,7 @@ describe("each gate decision appends exactly one transcript row", () => {
 
         const before = shell.streamLog.length
         closeInsetOverlay(shell)
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -482,7 +477,7 @@ describe("each gate decision appends exactly one transcript row", () => {
 
         const before = shell.streamLog.length
         acceptOverlaySelection(shell)
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -506,7 +501,7 @@ describe("each gate decision appends exactly one transcript row", () => {
 
         const before = shell.streamLog.length
         closeInsetOverlay(shell)
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -546,7 +541,7 @@ describe("each gate decision appends exactly one transcript row", () => {
           meta: false,
           option: false,
         } as unknown as KeyEvent)
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -569,7 +564,7 @@ describe("each gate decision appends exactly one transcript row", () => {
           timeoutMs: 5,
         })
         await new Promise((r) => setTimeout(r, 20))
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -593,20 +588,19 @@ describe("each gate decision appends exactly one transcript row", () => {
           signal: controller.signal,
         })
         controller.abort()
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
     })
   })
 
-  // The queue (settle-once guard) and the transcript recorder (record-once
-  // per decision) are two independent mechanisms layered on the same set of
-  // terminal paths. Racing a timeout against an abort on the same request
-  // exercises both at once: clearTimers must retire the loser before it can
-  // run autoDeny a second time, so ev.resolve fires exactly once and exactly
-  // one row lands, no matter which trigger wins.
-  test("a timeout and an abort racing the same request settle once and record once", async () => {
+  // The queue's settle-once guard is independent of the transcript: racing a
+  // timeout against an abort on the same request exercises that guard.
+  // clearTimers must retire the loser before it can run autoDeny a second
+  // time, so ev.resolve fires exactly once no matter which trigger wins, and
+  // neither path writes a recap row.
+  test("a timeout and an abort racing the same request settle once", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
@@ -633,14 +627,14 @@ describe("each gate decision appends exactly one transcript row", () => {
         controller.abort()
 
         expect(resolveCount).toBe(1)
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
     })
   })
 
-  test("a queued gate's timeout settles once and records once, only after it is displayed", async () => {
+  test("a queued gate's timeout settles once, only after it is displayed", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
@@ -673,7 +667,7 @@ describe("each gate decision appends exactly one transcript row", () => {
         await new Promise((r) => setTimeout(r, 20))
 
         expect(resolveCount).toBe(1)
-        expect(shell.streamLog.length - before).toBe(2) // first gate's row + the queued gate's timeout row
+        expect(shell.streamLog.length - before).toBe(0) // first gate + queued timeout both silent
       } finally {
         shell.dispose()
       }
@@ -682,8 +676,8 @@ describe("each gate decision appends exactly one transcript row", () => {
 
   // reconcile() (src/permission/queue.ts) settles a queued request directly
   // when a grant covers it, with no accept/cancel/autoDeny callback of its
-  // own to hang a row on — this is the one terminal path that has no natural
-  // call site, so it needs its own coverage.
+  // own. Coverage here is that the queued request still resolves, without
+  // ever opening and without writing a recap row.
   test("a grant draining a queued request without ever displaying it", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
@@ -717,17 +711,14 @@ describe("each gate decision appends exactly one transcript row", () => {
 
         expect(resolveCount).toBe(1)
         expect(resolved).toEqual({ allow: true })
-        expect(shell.streamLog.length - before).toBe(1)
-        expect(shell.streamLog.at(-1)?.text).toContain(
-          "Auto-approved (already granted)",
-        )
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
     })
   })
 
-  test("a grant draining the currently displayed request closes it and records once", async () => {
+  test("a grant draining the currently displayed request closes it without a recap", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
@@ -753,10 +744,7 @@ describe("each gate decision appends exactly one transcript row", () => {
 
         expect(resolveCount).toBe(1)
         expect(shell.overlayList).toBeNull()
-        expect(shell.streamLog.length - before).toBe(1)
-        expect(shell.streamLog.at(-1)?.text).toContain(
-          "Auto-approved (already granted)",
-        )
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -765,19 +753,18 @@ describe("each gate decision appends exactly one transcript row", () => {
 
   // drain() (src/permission/queue.ts) denies whatever is still queued on
   // teardown — the same no-call-site path as a grant drain, but the
-  // opposite outcome. Mislabeling this "Auto-approved" would tell the
-  // operator a request ran when it was actually dropped unanswered.
-  test("disposing with a request still queued records it as denied, not approved", async () => {
+  // opposite outcome. Coverage is the deny itself; neither path writes a
+  // recap row.
+  test("disposing with a request still queued denies it without a recap", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
         run: "idle",
       })
       const emitter = new EventEmitter()
       // The currently-open request has no accept/cancel/autoDeny call site
-      // triggered before teardown either, so dispose must record it too —
-      // both entries go through the same no-call-site fallback as the
-      // queued one.
+      // triggered before teardown either, so dispose must settle it too —
+      // both entries go through drain() without writing a recap.
       let openResolveCount = 0
       let queuedResolveCount = 0
       let queuedResolved: unknown
@@ -804,11 +791,7 @@ describe("each gate decision appends exactly one transcript row", () => {
       expect(openResolveCount).toBe(1)
       expect(queuedResolveCount).toBe(1)
       expect(queuedResolved).toEqual({ allow: false })
-      expect(shell.streamLog.length - before).toBe(2)
-      for (const row of shell.streamLog.slice(-2)) {
-        expect(row.text).toContain("Denied (session ended)")
-        expect(row.text).not.toContain("Auto-approved")
-      }
+      expect(shell.streamLog.length - before).toBe(0)
       shell.dispose()
     })
   })
@@ -1148,7 +1131,7 @@ describe("operator.gate auto-cancel", () => {
     })
   })
 
-  test("each terminal path writes exactly one transcript row", async () => {
+  test("each terminal path settles without writing a transcript row", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
@@ -1165,7 +1148,7 @@ describe("operator.gate auto-cancel", () => {
           timeoutMs: 5,
         })
         await new Promise((r) => setTimeout(r, 20))
-        expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.length - before).toBe(0)
       } finally {
         shell.dispose()
       }
@@ -1208,10 +1191,7 @@ describe("operator.gate auto-cancel", () => {
 
       expect(openResolved).toEqual(operatorCancelResult())
       expect(queuedResolved).toEqual(operatorCancelResult())
-      expect(shell.streamLog.length - before).toBe(2)
-      for (const row of shell.streamLog.slice(-2)) {
-        expect(row.text).toContain("Cancelled (session ended)")
-      }
+      expect(shell.streamLog.length - before).toBe(0)
       shell.dispose()
     })
   })