gaunt-sloth 2.0.0-beta.8 → 2.0.0

package/dist/tui/components/App.js

@@ -5,6 +5,9 @@ import { foldEvents, foldSubagentEvents, initialSubagentTree, initialTurnViewMod
 import { buildRejectionMessage } from '@gaunt-sloth/core/core/shell/rejection.js';
 import { ApprovalStopError } from '@gaunt-sloth/core/core/shell/approvalStop.js';
 import { shouldAnnounceTermination } from '@gaunt-sloth/core/core/terminationNotice.js';
+import { runEndReport } from '@gaunt-sloth/core/core/runRecap.js';
+import { providerErrorNotice } from '@gaunt-sloth/core/core/providerErrorNotice.js';
+import { readWaitNarration } from '@gaunt-sloth/core/core/waitNarration.js';
 import { attackBannerCopy, grantsRunAnyway, } from '@gaunt-sloth/core/core/shell/escalationSeverity.js';
 import { TranscriptViewport } from '#src/tui/components/TranscriptViewport.js';
 import { ApprovalPrompt } from '#src/tui/components/ApprovalPrompt.js';
@@ -22,15 +25,23 @@ import { ClearBanner } from '#src/tui/components/ClearBanner.js';
 import { LaunchBanner } from '#src/tui/components/LaunchBanner.js';
 import { MouseProvider } from '#src/tui/useMouse.js';
 import { DebugPanel, debugPanelLines, debugPanelRows, DEBUG_TABS, } from '#src/tui/components/DebugPanel.js';
+import { renderApprovalDetails } from '#src/tui/debugRender.js';
 import { approvalPostureChoices, approvalsRungNotice, approvalsRefusalsNotice, approvalsStatusNotice, approvalsTrustNotice, approvalsUndenyNotice, COMPACTING_LINE, compactionFailedNotice, autocompactNotice, autocompactUnavailableNotice, compactionNotice, compactionUnavailableNotice, createCommandRegistry, dispatchSlashCommand, parseSlashCommand, toolsToggleNotice, } from '@gaunt-sloth/agent/modules/slashCommands.js';
-import { resumedConversationNotice, resumeFailedNotice, resumePickerNotice, resumeRefusalNotice, resumeSameConversationNotice, resumeUnavailableNotice, } from '@gaunt-sloth/agent/modules/sessionResume.js';
+import { resumableConversationsNotice, resumedConversationNotice, resumeFailedNotice, resumeRefusalNotice, resumeSameConversationNotice, resumeUnavailableNotice, } from '@gaunt-sloth/agent/modules/sessionResume.js';
 import { ApprovalsPicker } from '#src/tui/components/ApprovalsPicker.js';
+import { ResumePicker, resumeCancelledNotice } from '#src/tui/components/ResumePicker.js';
 import { TerminalSizeProvider, useTerminalSize } from '#src/tui/useTerminalSize.js';
 import { findMatches, scrollOffsetForLine, stepMatch } from '#src/tui/debugSearch.js';
 import { useTranscriptScroll } from '#src/tui/useTranscriptScroll.js';
 import { isComposingKeystroke, WHEEL_ROWS_PER_NOTCH } from '#src/tui/transcriptScroll.js';
 import { TUI_HINT_SUFFIX, TUI_KEY_BINDINGS } from '#src/tui/keyBindings.js';
 import { isTypedText, typedText } from '#src/tui/keyGuards.js';
+/**
+ * The empty line list a debug tab that is not on screen hands the panel. A module-level constant so
+ * its identity is stable across renders: a fresh `[]` each time would make the memo that clamps the
+ * scroll offset recompute on every render of every other tab.
+ */
+const NO_DEBUG_LINES = [];
 /** Rows of clipping viewport in the docked debug panel (default / restored size). */
 const DEBUG_VIEWPORT_HEIGHT = 8;
 /** Rows of chrome around the debug viewport we leave for when it is maximised (panel
@@ -128,6 +139,15 @@ export function App(props) {
     const [transcript, setTranscript] = useState(seeded);
     const [live, setLive] = useState(null);
     const [running, setRunning] = useState(false);
+    /**
+     * [[EXT-92]] scope (a) — what the run is waiting on, when that is not the model answering.
+     *
+     * Held as the whole rendered sentence rather than an activity code, because the words are
+     * `core/waitNarration.ts`'s to choose: it is the module that reaches every surface, and a second
+     * spelling of the same wait on this one is the drift the exported prefix exists to prevent. The
+     * status bar renders it in place of its own default label, so this costs no row.
+     */
+    const [waitActivity, setWaitActivity] = useState(undefined);
     const [turnCount, setTurnCount] = useState(props.resumed?.turns.length ?? 0);
     // Subagent tree, folded from `task` tool calls on the live event stream. No backend dispatches
     // subagents in this release, so nothing fills it today; kept for GS2-25's lean primitive.
@@ -169,6 +189,11 @@ export function App(props) {
     // chrome: unlike the status notice it is never committed to the transcript, and it owns the
     // keyboard while mounted (the prompt is suspended below, as it is for a pending approval).
     const [approvalsPicker, setApprovalsPicker] = useState(null);
+    // GS2-112 — the open bare-`/resume` picker's candidates, or null when none is showing. Transient
+    // chrome on the same terms as the approvals picker above: never committed to the transcript, and
+    // it owns the keyboard while mounted. The list is the snapshot taken when the picker opened; a
+    // landed resume replaces the screen, so the picker is closed before the choice is applied.
+    const [resumePicker, setResumePicker] = useState(null);
     // Whether to show the post-`/clear` "history cleared" banner. Hidden again the moment the next
     // user turn starts so it doesn't linger above a fresh conversation.
     const [clearedBanner, setClearedBanner] = useState(false);
@@ -221,6 +246,14 @@ export function App(props) {
     // GS2-20 — starts past the seeded items so a later push never reuses a seeded key.
     const idRef = useRef(seeded.length);
     const runningRef = useRef(false);
+    /**
+     * [[EXT-92]] scope (e) — whether the turn now ending was ended by a throw.
+     *
+     * A ref rather than state because the only reader is the `finally` of the same async function
+     * the catch runs in: a `setState` would not be visible there, and the fact has to be true at the
+     * instant the turn is committed, not on the next render.
+     */
+    const turnErroredRef = useRef(false);
     /**
      * GS2-23 — whether a `/compact` is awaiting its summary. Read where `runningRef` is read at
      * submit, so a plain message cannot start a turn on a thread that is about to be rewritten, and
@@ -249,6 +282,22 @@ export function App(props) {
      */
     const conversationIdRef = useRef(props.conversationId);
     const turnCountRef = useRef(props.resumed?.turns.length ?? 0);
+    /**
+     * [[EXT-178]] — which conversation the outstanding recap request still belongs to.
+     *
+     * The recap is a model call launched detached at the end of a turn, so up to
+     * `RUN_RECAP_TIMEOUT_MS` can pass between asking and answering, and the session does not stand
+     * still for it: `/clear` empties the transcript the recap is describing, and a new turn can
+     * start and finish inside the window. Appending then puts a summary of a wiped conversation onto
+     * a blank screen, or files the previous turn's recap under this one.
+     *
+     * So the request carries the epoch it was made in and drops itself if the epoch has moved. It is
+     * bumped by exactly the three events that make a pending recap wrong: a new turn starting,
+     * `/clear`, and this component unmounting. It is deliberately NOT `turnCountRef`, which counts
+     * turns for the status bar, is incremented after the recap is launched, and is reset to 0 by
+     * `/clear` — a counter that goes backwards cannot be compared for staleness.
+     */
+    const recapEpochRef = useRef(0);
     // Per-turn args buffers for the subagent fold (mirrors foldSubagentTree's internal map).
     const subagentBuffersRef = useRef(new Map());
     const debugFocusedRef = useRef(false);
@@ -260,10 +309,11 @@ export function App(props) {
     // inside <PromptInput>, where it lives.
     const promptHandleRef = useRef(null);
     // TUI-C51 — the one thing about the prompt that has to outlive it: the message a command was
-    // dispatched beside. The prompt is unmounted in four states below, and one of them (`/approvals`
-    // opening its picker) is entered by a command dispatched FROM the prompt — so the draft is put
-    // here, where nothing unmounts, and the prompt takes it back when it returns. It stays a slot
-    // rather than state: nothing here renders it, and the prompt empties it as soon as it has it.
+    // dispatched beside. The prompt is unmounted in five states below, and two of them (`/approvals`
+    // and a bare `/resume` opening their pickers) are entered by a command dispatched FROM the
+    // prompt — so the draft is put here, where nothing unmounts, and the prompt takes it back when
+    // it returns. It stays a slot rather than state: nothing here renders it, and the prompt empties
+    // it as soon as it has it.
     const promptDraftCarryRef = useRef(null);
     // TUI-C79 — set the moment a teardown starts, so a second `quit()` can tell "leaving" from
     // "already leaving" and skip straight to the unmount. See `quit()`.
@@ -283,6 +333,18 @@ export function App(props) {
     const debugViewport = debugViewportHeight(debugMaximized, terminalRows);
     // PageUp/PageDown step tracks the live viewport so maximise pages by (almost) a full screen.
     const debugPageStep = Math.max(1, debugViewport - 1);
+    // [[TUI-C27]] — the Auto-mode tab's lines: the approvals gate's own record of every gated tool
+    // call, plus the rater config in force (already held here, since `/approvals` moves it).
+    //
+    // **Read fresh on every render while that tab is on screen, deliberately, and memoised on
+    // nothing.** The decision this tab exists for emits no event: a call the rater approves on its
+    // first rating relays nothing to any surface — the tool simply runs — so anything keyed on the
+    // approval, negotiation or turn signals the App already has would look live and miss exactly it.
+    // A pull costs one render of a capped (50-record) buffer, and only while a user is looking at
+    // the tab; every other tab keeps the stable empty array and pays nothing.
+    const debugAuto = debugVisible && debugTab === 'auto'
+        ? renderApprovalDetails(props.readApprovalCaptures?.() ?? [], approvals).split('\n')
+        : NO_DEBUG_LINES;
     // The active section's line count drives the real maximum scroll offset, so neither the page
     // step nor the arrow step can push the offset past the end (the over-scroll bug that left
     // PgUp/↑ burning through phantom offset before anything moved — TUI-C11). Single-sourced with
@@ -294,8 +356,9 @@ export function App(props) {
         toolsLines: debugTools,
         mcpLines: debugMcp,
         responseLines: debugResponse,
+        autoLines: debugAuto,
         activeTab: debugTab,
-    }), [subagents, debugHistory, debugSystem, debugTools, debugMcp, debugResponse, debugTab]);
+    }), [subagents, debugHistory, debugSystem, debugTools, debugMcp, debugResponse, debugAuto, debugTab]);
     const debugLineCount = debugLines.length;
     const debugMaxOffset = Math.max(0, debugLineCount - debugViewport);
     // Match line-indices for the current query over the active tab's lines — one search, every tab
@@ -394,6 +457,8 @@ export function App(props) {
         // A new exchange supersedes the post-/clear banner; drop it so it doesn't sit above
         // the fresh conversation.
         setClearedBanner(false);
+        // [[EXT-178]] — and it supersedes the previous turn's recap, which may still be in flight.
+        recapEpochRef.current += 1;
         push({ kind: 'user', text: userInput });
         // [[TUI-C69]] §5.4 — a new user turn is a person being reached, which ENDS any negotiation
         // still standing (the runner clears its own transcript on the same event). Rounds from the
@@ -403,11 +468,21 @@ export function App(props) {
         abortRef.current = ac;
         runningRef.current = true;
         setRunning(true);
+        // [[EXT-92]] — both per-turn facts start clean. `turnErroredRef` (scope e) is set by the
+        // catch and read by the `finally`; `waitActivity` (scope a) is a label the status bar may
+        // still be holding from the previous turn's last wait.
+        turnErroredRef.current = false;
+        setWaitActivity(undefined);
         setLiveTurn(initialTurnViewModel());
         // Fresh args-buffer map per turn so partial `task` JSON from a prior turn never bleeds in.
         subagentBuffersRef.current = new Map();
         try {
             for await (const event of agent.runTurn(userInput, ac.signal)) {
+                // [[EXT-92]] scope (a) — an event arriving IS the wait ending. Clearing here rather than
+                // waiting for a paired "done" narration is what keeps the core signal one-way and the
+                // plain surface to exactly one line per wait: there is no end message to emit, so there
+                // is none to print. The status bar falls back to its own default label.
+                setWaitActivity(undefined);
                 // [[TUI-C99]] — folded from the REF, not from a local: an approval answered mid-turn
                 // writes the outcome onto its tool call from a keystroke, and a local carried across the
                 // loop would overwrite it on the very next event the resumed run produces.
@@ -427,16 +502,43 @@ export function App(props) {
                 push({ kind: 'stop', parts: err.parts });
             }
             else {
+                // [[EXT-92]] scope (b) — a provider error is rendered as prose here, and the raw payload
+                // rides along in a field this item's renderer never prints.
+                //
+                // The whole defect was on this line. `err.message` for an OpenRouter refusal is
+                // `Provider returned error | metadata: {…}` — upstream flattens its own structured
+                // metadata into the message — so the user read a JSON blob while the provider's own
+                // sentence, its remedy hint, and the fact that it was a SHARED pool rather than their
+                // quota all sat unread inside it. Nothing had been lost: the same fields are still
+                // objects on `err`, which is why this needed a renderer rather than a parser.
+                // `providerErrorNotice` returns null for the ordinary runtime errors it has nothing to
+                // add to, and those keep exactly the rendering they had.
+                const notice = providerErrorNotice(err);
                 push({
                     kind: 'system',
                     level: 'error',
-                    text: err instanceof Error ? err.message : String(err),
+                    text: notice?.text ?? (err instanceof Error ? err.message : String(err)),
+                    ...(notice ? { raw: notice.raw } : {}),
                 });
             }
+            // [[EXT-92]] scope (e) — remember that this turn was ended by the failure above, so the
+            // `finally` can commit it as a turn that STOPPED rather than one that finished. An
+            // approvals stop is deliberately excluded: it already commits its own `stop` item saying
+            // so in full, and marking the turn as well would state the same ending twice.
+            if (!(err instanceof ApprovalStopError))
+                turnErroredRef.current = true;
         }
         finally {
+            // [[EXT-92]] scope (a) — the turn is over, so nothing is being waited on. In the `finally`
+            // because the endings that most need it are the ones that reach neither the loop's normal
+            // exit nor the catch: a turn cancelled mid-rating would otherwise leave the bar naming a
+            // wait that no longer exists.
+            setWaitActivity(undefined);
             const vm = liveVmRef.current ?? initialTurnViewModel();
-            push({ kind: 'assistant', turn: vm });
+            push({
+                kind: 'assistant',
+                turn: turnErroredRef.current ? { ...vm, endedInError: true } : vm,
+            });
             // [[EXT-159]] — and, immediately under the answer, why the turn ended when that is not
             // simply "the model finished".
             //
@@ -454,6 +556,50 @@ export function App(props) {
                 const reason = agent.getTerminationReason?.() ?? null;
                 if (reason && shouldAnnounceTermination(reason))
                     push({ kind: 'termination', reason });
+                // [[EXT-158]] — and the other silence: a turn that ended cleanly with its own checklist
+                // still carrying work. `shouldAnnounceTermination` declines `completed`, correctly — an
+                // ordinary answer needs no epitaph — which is exactly why this case had nothing at all.
+                //
+                // Committed as an ordinary `notice` item rather than a transcript kind of its own. The
+                // termination item earns its kind by carrying the REASON value so the transcript holds
+                // the classification rather than a rendered line; this fact has no such closed taxonomy
+                // to preserve, and a new kind would buy a second row-count case and a second renderer for
+                // a title and three lines the generic notice already draws.
+                //
+                // [[EXT-178]] — and its successor when the user has switched the recap on. The two speak
+                // for the same population, so exactly one of them is drawn: `runEndReport` decides, with
+                // the recap already resolved, and a recap that never arrived leaves the notice standing.
+                //
+                // **Detached from the turn's teardown, and that is the whole reason it is down here.**
+                // A recap is a model call made after the answer is already on screen; awaiting it in this
+                // `finally` would keep the spinner running and the prompt away for as long as a provider
+                // takes to reply, which is a worse thing to do to a finished turn than a late paragraph.
+                // The transcript is append-only and this lands at the bottom, where the reader is. With
+                // the default `off` rung nothing is contacted and the notice lands as it always did.
+                const work = agent.getOutstandingWork?.() ?? null;
+                const ending = reason;
+                // Detached means the session can move on underneath it, so the request carries the epoch
+                // it was made in and says nothing if `recapEpochRef` has moved on — see that ref.
+                const epoch = recapEpochRef.current;
+                void (async () => {
+                    try {
+                        const recap = (await agent.requestRunRecap?.(ending)) ?? null;
+                        if (recapEpochRef.current !== epoch)
+                            return;
+                        const report = runEndReport(recap, work, ending);
+                        if (report.kind !== 'silent') {
+                            push({
+                                kind: 'notice',
+                                title: report.notice.title,
+                                lines: report.notice.lines,
+                                tone: report.kind === 'recap' ? 'info' : 'warn',
+                            });
+                        }
+                    }
+                    catch {
+                        /* fail-soft: explaining a turn must never be what breaks the session */
+                    }
+                })();
             }
             catch {
                 /* fail-soft: explaining a turn must never be what breaks the session */
@@ -715,7 +861,31 @@ export function App(props) {
     // replaces the screen: the transcript on it belonged to the conversation being left, and the
     // model is now continuing another one, so the banner and the restored turns take its place —
     // the same wipe `/clear` does, without the cleared banner, because nothing was discarded (the
-    // conversation left keeps everything recorded under it). Bare, it lists what could be resumed.
+    // conversation left keeps everything recorded under it). Bare, this surface offers the picker
+    // below; the readline session prints the list.
+    //
+    // GS2-112 — **why the interactive picker is one branch here and not a new protocol field.**
+    //
+    // `/resume` returns `resume?: { id?: number }`, and the missing id is not an omission to be
+    // filled in later: the command is pure and cannot reach the store or the runner, so the no-id
+    // case has always meant *the surface fulfils this*, which is what every other surface already
+    // does with it. The Ink TUI can show a list and read arrow keys; the readline session can print
+    // one; a server surface has no user at a keyboard at all. Choosing is therefore the surface's
+    // answer to the same request, and nothing in the request needs to change for this surface to
+    // give a better one.
+    //
+    // The alternative was weighed and rejected rather than overlooked. A cross-package chooser — a
+    // new result field carrying candidates, or a `chooseConversation` callback threaded from the
+    // agent down into the component — would put a widget's contract in the module both surfaces
+    // read from, to serve one surface, and would still leave this branch deciding when to open it.
+    // It buys nothing: the candidates are already here (`props.listResumeCandidates`, wired in
+    // `tuiSessionModule`), and the id the user picks re-enters the with-id path below, which is the
+    // same code `--resume <id>` runs at boot. One branch, one new component, no new protocol.
+    //
+    // **The readline surface keeps the printed list deliberately.** It is not a fallback that has
+    // been left behind: with no Ink tree there is nothing to arrow through, and the printed ids
+    // remain the only way in on that surface — so `resumableConversationsNotice` stays its list
+    // builder, and no picker wording is allowed to leak into it (pinned by a spec).
     const applyResume = useCallback(async (id) => {
         const commit = (notice) => push({
             kind: 'notice',
@@ -724,11 +894,23 @@ export function App(props) {
             tone: notice.tone ?? 'info',
         });
         if (id === undefined) {
+            // A session with no store behind it cannot list anything, let alone offer it: this prop is
+            // wired only where history is on and a store opened, so its absence is the same "resume is
+            // unavailable here" the with-id path reports below.
             if (!props.listResumeCandidates) {
                 commit(resumeUnavailableNotice());
                 return;
             }
-            commit(resumePickerNotice(props.listResumeCandidates()));
+            const candidates = props.listResumeCandidates();
+            // With nothing to offer, say so and open nothing. An empty <SelectList> renders a "no
+            // matches" line and its Enter is inert, so a picker here would be a modal the user can
+            // only escape from — strictly worse than the sentence, which also explains what makes a
+            // conversation resumable.
+            if (candidates.length === 0) {
+                commit(resumableConversationsNotice(candidates));
+                return;
+            }
+            setResumePicker(candidates);
             return;
         }
         if (!agent.resumeConversation) {
@@ -1049,6 +1231,10 @@ export function App(props) {
                 conversationId: conversationIdRef.current,
                 toolsExpanded: toolsExpandedRef.current,
                 debugVisible: debugVisibleRef.current,
+                // TUI-C96 — this surface has the slash-command menu (<PromptInput> renders it
+                // unconditionally), so the unknown-command notice may explain a shortened name by
+                // pointing at it. The readline surface says false and gets the other sentence.
+                hasSlashMenu: true,
                 // TUI-C37 — undefined (not false) when this surface has no mouse layer, so `/mouse`
                 // says it is unavailable rather than silently reporting "off".
                 mouseEnabled: props.mouseEnabled === undefined ? undefined : mouseEnabledRef.current,
@@ -1059,6 +1245,10 @@ export function App(props) {
                 // TUI-C19 — the actual validation warnings so `/config` renders the details the
                 // standing advisory line points at.
                 configWarnings: props.advisories,
+                // GS2-88 — the three summaries AND the reason they may be empty, so a command with
+                // nothing to show names the cause the session actually established rather than the
+                // config. Both surfaces pass all four, from the one core builder.
+                historyAvailability: props.historyAvailability,
                 historySummary: props.historySummary,
                 insightsSummary: props.insightsSummary,
                 historySearch: props.historySearch,
@@ -1097,11 +1287,19 @@ export function App(props) {
                 // thread intact (the LangGraph checkpointer replays it on the next turn), so the
                 // model would still "remember" everything. Reset the agent's thread too so the
                 // model context truly matches the now-empty transcript (TUI-C8).
-                agent.resetThread?.();
+                //
+                // [[EXT-109]] — and the agent's own record of the conversation goes with it: the
+                // approvals gate's capture log is what the Auto-mode tab above and a later
+                // `/debug-dump` read, and every other pane cleared here would otherwise sit beside one
+                // that still quotes the user's pre-`/clear` messages.
+                agent.clearConversation?.();
                 // The status-bar turn counter is part of the conversation state we just wiped, so
                 // reset it too — a cleared session starts back at "turns: 0".
                 turnCountRef.current = 0;
                 setTurnCount(0);
+                // [[EXT-178]] — a recap still in flight describes the conversation just wiped, so drop
+                // it rather than append a summary of nothing onto a cleared screen.
+                recapEpochRef.current += 1;
             }
             if (result.toggleTools) {
                 // Flip the fold mode and commit the notice via the shared helper (single-sourced with
@@ -1206,7 +1404,7 @@ export function App(props) {
     //     path never registers gsloth's readline Esc handler, so Ink owns raw mode cleanly).
     //  3. Tab while the panel is visible and idle → focus/cycle the panel.
     //  4. While the panel is focused → Tab/Shift+Tab cycle sections, ↑/↓ scroll one line,
-    //     PageUp/PageDown page-step, m maximises, Esc unfocuses.
+    //     PageUp/PageDown page-step, m maximises, Esc leaves the pane (restoring a maximised one).
     useInput((input, key) => {
         // [[TUI-C79]] — **Ctrl+C is this app's, not Ink's**, and it is answered here before anything
         // else can claim it. `render()` takes `exitOnCtrlC: false` (`tuiSessionModule.tsx`), which is
@@ -1227,13 +1425,19 @@ export function App(props) {
         //     bare `exit` keyword all take it too).
         //
         // **The modal states are answered first, and they exit.** While an attack banner, an approval
-        // prompt or the approvals picker owns the keyboard, a turn IS in flight, so rung 2 would read
-        // "stop the turn" where the banner's own controls line says `Ctrl+C exits gth` and the user is
-        // looking for the way out of an irreversible action. So it exits, as the screen promises — and
-        // it goes through `quit()`, which resolves both bridges fail-closed on the way out rather than
-        // leaving the halt unanswered.
+        // prompt or one of the pickers (`/approvals`, bare `/resume`) owns the keyboard, the prompt is
+        // unmounted, so rung 1 has no buffer to scrap; and where that modal state was reached during a
+        // turn, rung 2 would read "stop the turn" while the banner's own controls line says `Ctrl+C
+        // exits gth` and the user is looking for the way out of an irreversible action. So it exits, as
+        // the screen promises — and it goes through `quit()`, which resolves both bridges fail-closed
+        // on the way out rather than leaving the halt unanswered.
+        //
+        // GS2-112 — the resume picker is in this set for coherence rather than for a case it changes
+        // today: `/resume` is idle-only and the prompt is unmounted while its picker is up, so no turn
+        // can be started under it and the ladder would fall to rung 3 and exit anyway. Naming it here
+        // is what keeps that answer from depending on which rung happens to catch it.
         if (key.ctrl && input === 'c') {
-            if (pendingAttack || pendingApproval || approvalsPicker) {
+            if (pendingAttack || pendingApproval || approvalsPicker || resumePicker) {
                 quit();
                 return;
             }
@@ -1369,11 +1573,11 @@ export function App(props) {
                 resolveApproval('reject');
             return;
         }
-        // CFG-39 — while the `/approvals` picker is open it OWNS the keyboard, exactly as a pending
-        // approval does. <SelectList> is a useInput subscriber too and Ink runs every subscriber, so
-        // without this the arrow keys would also scroll the transcript and Esc would both cancel the
-        // picker and jump to the newest output. Returning here leaves the picker the only claimant.
-        if (approvalsPicker)
+        // CFG-39, GS2-112 — while a picker is open it OWNS the keyboard, exactly as a pending approval
+        // does. <SelectList> is a useInput subscriber too and Ink runs every subscriber, so without
+        // this the arrow keys would also scroll the transcript and Esc would both cancel the picker and
+        // jump to the newest output. Returning here leaves the picker the only claimant.
+        if (approvalsPicker || resumePicker)
             return;
         if (key.escape && runningRef.current) {
             abortRef.current?.abort();
@@ -1437,7 +1641,17 @@ export function App(props) {
                 }
                 return;
             }
-            // Esc layering: clear an active search first (less-style), else unfocus the pane.
+            // Esc layering: clear an active search first (less-style), else LEAVE the pane — and leaving
+            // it drops the maximised view as well as focus, in the one press.
+            //
+            // TUI-C107 — focus and maximisation are one state as far as an exit is concerned, so an exit
+            // that dropped only one of them left the user with nothing to press. The prompt is unmounted
+            // while the pane holds focus (the render's `!debugFocused` guard), and a maximised pane takes
+            // the terminal height minus DEBUG_MAX_CHROME_ROWS, so the prompt has no rows to draw in even
+            // once focus is gone: dropping focus alone left the session with no visible prompt, and `m` —
+            // the key that would undo the maximisation — is handled inside this focused-only branch, so
+            // it no longer answered either. Same pairing, and the same reason, as the /debug toggle's
+            // "focus never lingers on a hidden panel" above.
             if (key.escape) {
                 if (debugSearchQueryRef.current) {
                     clearDebugSearch();
@@ -1445,6 +1659,7 @@ export function App(props) {
                 }
                 setDebugFocused(false);
                 debugFocusedRef.current = false;
+                setDebugMaximized(false);
                 return;
             }
             // `/` opens the search input (scoped to pane focus — the seam).
@@ -1588,6 +1803,12 @@ export function App(props) {
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
+    // [[EXT-178]] — the third thing that invalidates a recap still in flight: this component going
+    // away. A quit unmounts while a provider may still be holding the request open, and the reply
+    // would then land on a session the user has left.
+    useEffect(() => () => {
+        recapEpochRef.current += 1;
+    }, []);
     // Route agent status updates (warnings/errors) into the transcript instead of stdout,
     // which would otherwise corrupt Ink's frame. INFO/DEBUG system lines are suppressed in the
     // TUI: the agent's per-turn chatter (`Requested tools`, `Loaded tools`, `Workdir`, `Model`,
@@ -1598,6 +1819,17 @@ export function App(props) {
         if (!props.subscribeStatus)
             return;
         return props.subscribeStatus((level, message) => {
+            // [[EXT-92]] scope (a) — a wait narration is INFO, and INFO is exactly what this handler
+            // drops, so it is picked out BEFORE the filter and routed to the status bar instead of the
+            // transcript. That is the right destination on both counts: it is a transient fact about the
+            // present moment, which the transcript is the wrong shape for, and the bar is already the
+            // TUI's wait renderer. Recognised by the prefix `core/waitNarration.ts` exports for this,
+            // rather than by a copy of the wording here.
+            const narration = readWaitNarration(message);
+            if (narration !== null) {
+                setWaitActivity(narration);
+                return;
+            }
             if (level === 'INFO' || level === 'DEBUG')
                 return;
             if (message.trim())
@@ -1679,10 +1911,19 @@ export function App(props) {
             : 0) -
         (activeChecklist ? checklistPanelRows(activeChecklist) : 0) -
         negotiationPanelRows(negotiationRounds, terminalColumns);
-    return (_jsx(TerminalSizeProvider, { size: terminalSize, children: _jsx(MouseProvider, { subscribe: props.subscribeMouse, enabled: mouseEnabled, children: _jsxs(Box, { flexDirection: "column", height: terminalRows, children: [_jsxs(TranscriptViewport, { items: transcript, budgetRows: terminalRows, columns: terminalColumns, toolsExpanded: toolsExpanded, scroll: transcriptScroll, regionRows: transcriptRegionRows, geometry: transcriptGeometry, children: [clearedBanner ? _jsx(ClearBanner, {}) : null, showIntro && props.showLaunchBanner ? (_jsx(LaunchBanner, { model: modelDisplayName, provider: props.modelProviderType })) : null, showIntro ? _jsx(Text, { dimColor: true, children: readyMessage.trim() }) : null, live && transcript.length > 0 ? _jsx(BlankRow, {}) : null, live ? (_jsx(LiveTurn, { turn: live, toolsExpanded: toolsExpanded, streaming: true, columns: terminalColumns })) : null, pendingApproval ? (_jsxs(_Fragment, { children: [live || transcript.length > 0 ? _jsx(BlankRow, {}) : null, _jsx(ApprovalRequestPanel, { pending: pendingApproval.pending, columns: terminalColumns })] })) : null] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [debugVisible ? (_jsx(DebugPanel, { subagents: subagents, historyLines: debugHistory, systemLines: debugSystem, toolsLines: debugTools, mcpLines: debugMcp, responseLines: debugResponse, activeTab: debugTab, scrollOffset: debugScroll, focused: debugFocused, viewportHeight: debugViewport, maximized: debugMaximized, searchQuery: debugSearchQuery, searchActive: debugSearchInput, matchCount: debugMatches.length, currentMatchIndex: debugSearchCurrent, currentMatchLine: currentMatchLine })) : null, activeChecklist ? _jsx(ChecklistPanel, { items: activeChecklist }) : null, _jsx(NegotiationPanel, { rounds: negotiationRounds }), pendingAttack ? _jsx(AttackBanner, { halt: pendingAttack.halt, typed: attackTyped }) : null, pendingApproval && !pendingAttack ? (_jsx(ApprovalPrompt, { pending: pendingApproval.pending })) : null, approvalsPicker && !pendingApproval && !pendingAttack ? (_jsx(ApprovalsPicker, { choices: approvalsPicker, onSelect: (rung) => {
+    return (_jsx(TerminalSizeProvider, { size: terminalSize, children: _jsx(MouseProvider, { subscribe: props.subscribeMouse, enabled: mouseEnabled, children: _jsxs(Box, { flexDirection: "column", height: terminalRows, children: [_jsxs(TranscriptViewport, { items: transcript, budgetRows: terminalRows, columns: terminalColumns, toolsExpanded: toolsExpanded, scroll: transcriptScroll, regionRows: transcriptRegionRows, geometry: transcriptGeometry, children: [clearedBanner ? _jsx(ClearBanner, {}) : null, showIntro && props.showLaunchBanner ? (_jsx(LaunchBanner, { model: modelDisplayName, provider: props.modelProviderType })) : null, showIntro ? _jsx(Text, { dimColor: true, children: readyMessage.trim() }) : null, live && transcript.length > 0 ? _jsx(BlankRow, {}) : null, live ? (_jsx(LiveTurn, { turn: live, toolsExpanded: toolsExpanded, streaming: true, columns: terminalColumns })) : null, pendingApproval ? (_jsxs(_Fragment, { children: [live || transcript.length > 0 ? _jsx(BlankRow, {}) : null, _jsx(ApprovalRequestPanel, { pending: pendingApproval.pending, columns: terminalColumns })] })) : null] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [debugVisible ? (_jsx(DebugPanel, { subagents: subagents, historyLines: debugHistory, systemLines: debugSystem, toolsLines: debugTools, mcpLines: debugMcp, responseLines: debugResponse, autoLines: debugAuto, activeTab: debugTab, scrollOffset: debugScroll, focused: debugFocused, viewportHeight: debugViewport, maximized: debugMaximized, searchQuery: debugSearchQuery, searchActive: debugSearchInput, matchCount: debugMatches.length, currentMatchIndex: debugSearchCurrent, currentMatchLine: currentMatchLine })) : null, activeChecklist ? _jsx(ChecklistPanel, { items: activeChecklist }) : null, _jsx(NegotiationPanel, { rounds: negotiationRounds }), pendingAttack ? _jsx(AttackBanner, { halt: pendingAttack.halt, typed: attackTyped }) : null, pendingApproval && !pendingAttack ? (_jsx(ApprovalPrompt, { pending: pendingApproval.pending })) : null, approvalsPicker && !pendingApproval && !pendingAttack ? (_jsx(ApprovalsPicker, { choices: approvalsPicker, onSelect: (rung) => {
                                     setApprovalsPicker(null);
                                     applyApprovalRung(rung);
-                                }, onCancel: () => setApprovalsPicker(null) })) : null, _jsx(BlankRow, {}), _jsx(Rule, {}), _jsx(NoticeBar, { advisories: props.advisories }), _jsx(McpFailureBar, { failures: props.mcpFailures }), _jsx(StatusBar, { running: running, mode: mode, modelDisplayName: modelDisplayName, 
+                                }, onCancel: () => setApprovalsPicker(null) })) : null, resumePicker && !approvalsPicker && !pendingApproval && !pendingAttack ? (_jsx(ResumePicker, { candidates: resumePicker, onSelect: (id) => {
+                                    // Close BEFORE applying: a landed resume replaces the transcript and re-keys its
+                                    // ids, and this list is a snapshot of the conversations as they were before it.
+                                    setResumePicker(null);
+                                    void applyResume(id);
+                                }, onCancel: () => {
+                                    setResumePicker(null);
+                                    const notice = resumeCancelledNotice();
+                                    push({ kind: 'notice', title: notice.title, lines: notice.lines, tone: 'info' });
+                                } })) : null, _jsx(BlankRow, {}), _jsx(Rule, {}), _jsx(NoticeBar, { advisories: props.advisories }), _jsx(McpFailureBar, { failures: props.mcpFailures }), _jsx(StatusBar, { running: running, activity: waitActivity, mode: mode, modelDisplayName: modelDisplayName, 
                                 // CFG-38 — the provider beside the model, and the live width it has to fit in: the
                                 // bar drops the provider rather than overflowing a narrow terminal.
                                 modelProviderType: props.modelProviderType, columns: terminalColumns, turnCount: turnCount, debugHint: debugVisible && !debugFocused, approvals: approvals
@@ -1690,7 +1931,11 @@ export function App(props) {
                                         rung: approvals.rung,
                                         raterProfile: approvals.rater,
                                     }
-                                    : undefined }), !debugFocused && !pendingApproval && !pendingAttack && !approvalsPicker ? (_jsxs(_Fragment, { children: [_jsx(BlankRow, {}), _jsx(PromptInput, { onSubmit: handleSubmit, commands: registry, onMenuStateChange: (active) => {
+                                    : undefined }), !debugFocused &&
+                                !pendingApproval &&
+                                !pendingAttack &&
+                                !approvalsPicker &&
+                                !resumePicker ? (_jsxs(_Fragment, { children: [_jsx(BlankRow, {}), _jsx(PromptInput, { onSubmit: handleSubmit, commands: registry, onMenuStateChange: (active) => {
                                             slashMenuActiveRef.current = active;
                                         }, handleRef: promptHandleRef, draftCarryRef: promptDraftCarryRef, promptBlockRows: promptBlockRows }), _jsx(BlankRow, {})] })) : null, _jsx(Text, { dimColor: true, wrap: "truncate-end", children: `${exitMessage.trim()}${TUI_HINT_SUFFIX}` }), _jsx(Rule, {})] })] }) }) }));
 }