gaunt-sloth 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/tui/components/App.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { foldEvents, foldSubagentEvents, initialSubagentTree, initialTurnViewModel, turnReasoning, turnText, } from '#src/tui/viewModel.js';
@@ -9,22 +9,25 @@ import { TranscriptViewport } from '#src/tui/components/TranscriptViewport.js';
 import { ApprovalPrompt } from '#src/tui/components/ApprovalPrompt.js';
 import { AttackBanner } from '#src/tui/components/AttackBanner.js';
 import { LiveTurn, ChecklistPanel } from '#src/tui/components/LiveTurn.js';
+import { NegotiationPanel } from '#src/tui/components/NegotiationPanel.js';
 import { extractActiveChecklist } from '#src/tui/viewModel.js';
 import { StatusBar } from '#src/tui/components/StatusBar.js';
 import { NoticeBar, McpFailureBar } from '#src/tui/components/NoticeBar.js';
 import { PromptInput } from '#src/tui/components/PromptInput.js';
 import { Rule } from '#src/tui/components/Rule.js';
+import { BlankRow } from '#src/tui/components/BlankRow.js';
 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, DEBUG_TABS, } from '#src/tui/components/DebugPanel.js';
-import { approvalPostureChoices, approvalsRungNotice, approvalsStatusNotice, approvalsTrustNotice, createCommandRegistry, dispatchSlashCommand, parseSlashCommand, toolsToggleNotice, } from '@gaunt-sloth/agent/modules/slashCommands.js';
+import { approvalPostureChoices, approvalsRungNotice, approvalsRefusalsNotice, approvalsStatusNotice, approvalsTrustNotice, approvalsUndenyNotice, createCommandRegistry, dispatchSlashCommand, parseSlashCommand, toolsToggleNotice, } from '@gaunt-sloth/agent/modules/slashCommands.js';
 import { ApprovalsPicker } from '#src/tui/components/ApprovalsPicker.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';
 /** 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
@@ -124,10 +127,17 @@ export function App(props) {
     // The head is the approval on screen AND the one that owns the keyboard. Deriving both from this
     // single expression is what keeps those two facts from drifting apart.
     const pendingApproval = approvalQueue[0] ?? null;
+    // [[EXT-137]] — the queue records whose scrollable half has already been committed to the
+    // transcript, so a re-render cannot commit a second copy. See the effect that fills it.
+    const announcedApprovals = useRef(new Set());
     // [[TUI-C68]] §6.1 — attack halts, queued exactly as approvals are, and for the same reason: the
     // head is what is on screen AND what owns the keyboard, from one expression.
     const [attackQueue, setAttackQueue] = useState([]);
     const pendingAttack = attackQueue[0] ?? null;
+    // [[TUI-C69]] §5.4 — the §5 negotiation's rounds as they happen. A LIST rather than a queue,
+    // because nothing is being answered: it is the argument so far, accumulating while the turn is
+    // in flight and cleared when the next user turn ends the negotiation.
+    const [negotiationRounds, setNegotiationRounds] = useState([]);
     // What the human has typed into the banner. Held in a ref BESIDE the state because Ink dispatches
     // every keypress parsed out of one stdin chunk in a synchronous loop: typing `run` can run the
     // handler three times before a single re-render, and reading the state would give all three the
@@ -157,6 +167,12 @@ export function App(props) {
     // first rung asks the buffer to scrap itself through this; everything else about the buffer stays
     // 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.
+    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()`.
     const quittingRef = useRef(false);
@@ -255,6 +271,10 @@ export function App(props) {
         // the fresh conversation.
         setClearedBanner(false);
         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
+        // previous turn left on the dock would claim an argument that is over.
+        setNegotiationRounds([]);
         const ac = new AbortController();
         abortRef.current = ac;
         runningRef.current = true;
@@ -404,20 +424,49 @@ export function App(props) {
             });
             return;
         }
-        const { approvals: current, allowlist, deny, grants, trust } = agent.getApprovals();
+        const { approvals: current, allowlist, refusals, grants, trust } = agent.getApprovals();
         approvalsRef.current = current;
         setApprovals(current);
         // `interactive` suppresses the notice's TEXT copy of the mode list, because the picker below is
         // about to render the same four rows. Every non-TTY surface leaves it unset and gets the text.
-        const { title, lines, tone } = approvalsStatusNotice(current, allowlist, deny, grants, trust, {
-            interactive: true,
-        });
+        const { title, lines, tone } = approvalsStatusNotice(current, allowlist, refusals, grants, trust, { interactive: true });
         push({ kind: 'notice', title, lines, tone: tone ?? 'info' });
+        // [[EXT-107]] — the refusals as a SECOND notice, after the posture one. Two notices rather than
+        // a longer one: this pane is full to the row once the picker below is up, so rows added to the
+        // posture notice scroll its own heading — the mode the user just asked about — off the top.
+        const refused = approvalsRefusalsNotice(refusals);
+        if (refused) {
+            push({
+                kind: 'notice',
+                title: refused.title,
+                lines: refused.lines,
+                tone: refused.tone ?? 'info',
+            });
+        }
         // Only offer to CHANGE the mode when this session can actually apply one.
         if (agent.setApprovalRung)
             setApprovalsPicker(approvalPostureChoices(current.rung));
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [agent]);
+    // [[EXT-107]] — `/approvals undeny <n>`: lift one refusal. Same division as the rung and the
+    // trust change — the runner owns the lists, applies the removal and reports what LANDED, and the
+    // notice is built from that, never from what was asked for. This is the escape hatch from a
+    // refusal that is now written to a project file, so it degrades loudly rather than silently when
+    // a session has no runner behind it.
+    const liftRefusal = useCallback((index) => {
+        if (!agent.liftRefusal) {
+            push({
+                kind: 'system',
+                level: 'warning',
+                text: 'Approvals are unavailable in this session.',
+            });
+            return;
+        }
+        const { title, lines, tone } = approvalsUndenyNotice(agent.liftRefusal(index));
+        push({ kind: 'notice', title, lines, tone: tone ?? 'info' });
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [agent]);
     // EXT-70 §4.7.1 — `/approvals trust|untrust <server> <hint…>`: believe, or stop believing,
     // specific annotation hints from one MCP server for this session. Same division as the rung: the
     // runner owns the posture, applies the change and reports what LANDED, and the notice is built
@@ -463,75 +512,141 @@ export function App(props) {
     // Resolve the currently-shown approval (the queue head) and commit a brief notice so the
     // decision reads in the transcript (TUI-C14 notice conventions). Dequeues the head so the next
     // queued approval (if any) surfaces. Approve carries the chosen scope; reject is fail-closed.
+    //
+    // [[EXT-150]] — **an answer that promises a FILE waits to be told what it got.** The two `always`
+    // answers ask for something the runner may not be able to do: [[EXT-149]] degrades an `always`
+    // whose write did not reach disk to the session answer it really is, and decides that only after
+    // this surface's decision has already been handed back. Written from the keystroke, the
+    // confirmation is a claim about a file nobody has tried to write yet — and on a checkout that
+    // cannot be written it says *saved to this project* beside core's own ERROR naming the file it
+    // could not save to. So `resolve` now answers back, and the two sticky notices are committed from
+    // what LANDED (DL-4: confirming something that did not happen is a transparency failure).
+    //
+    // **One notice, once, when it is known** — never an optimistic line corrected afterwards. A claim
+    // that appears and then changes is its own defect, and a user who read the first version has
+    // already acted on it.
     const resolveApproval = (decision) => {
         const head = pendingApproval;
         if (!head)
             return;
+        // [[EXT-150]] — **dequeue on the keystroke, ahead of any wait.** The dialog leaving the screen
+        // is what makes the answer feel taken, and the next queued approval must surface at once. A
+        // dequeue moved below the wait would hold the interface for as long as a write takes, and hold
+        // it forever if the outcome never came — trading a false sentence for a wedged prompt.
+        setApprovalQueue((q) => q.slice(1));
         if (decision === 'reject' || decision === 'reject-always') {
             // [[TUI-C26]] §6 — *always reject* is a rejection that is also REMEMBERED: the runner records
             // a deny entry for this call, and the matcher consults it before anything else, so the next
             // identical call never reaches a person. `once` is the ordinary refusal and the fallthrough
             // every unbound key lands on.
             const sticky = decision === 'reject-always';
-            // EXT-58 (§7): hand the model the moves it has (re-call with a justification, a different
-            // command, or ask the user) plus — when the rater named an already-granted alternative
-            // (§4.4) — that tool and the clause saying it will not interrupt the user. This is the
-            // message the MODEL sees; the on-screen notice below is unchanged.
-            head.resolve({
+            // EXT-58 (§7): hand the model the moves it has (re-call with a justification, or a
+            // different command) plus — when the rater named an already-granted alternative (§4.4) —
+            // that tool and the clause saying it will not interrupt the user. This is the message the
+            // MODEL sees, and it is a different thing from the on-screen notice below: one is addressed
+            // to the agent and one to the person, and neither is derived from the other.
+            const outcome = head.resolve({
                 type: 'reject',
-                ...(sticky ? { scope: 'session' } : {}),
+                // [[EXT-107]] — `always`, which is what the menu label promised. The lifetime that actually
+                // lands is core's to decide (a project file that cannot be written degrades to a session
+                // refusal), so this surface asks for the scope and never assumes the outcome.
+                ...(sticky ? { scope: 'always' } : {}),
                 message: buildRejectionMessage({
                     source: 'user',
                     toolName: head.pending.name,
                     verdict: head.pending.safetyVerdict,
                 }),
             });
-            push({
-                kind: 'notice',
-                title: sticky ? 'Command refused for this session' : 'Command rejected',
-                lines: sticky
-                    ? [
-                        // Exactly what it does, and no more. There is no persisted deny store, so a line
-                        // implying one would be §6's "offered and then refused" with the evidence hidden —
-                        // and the refusal itself is real, which is what makes the honest wording affordable.
-                        // The call is deliberately NOT quoted here: a transcript notice is painted raw, and
-                        // the command is the untrusted string this whole dialog frames.
-                        'This call will be refused for the rest of this session, without asking again.',
-                        'Nothing was saved to the project, so a new session will ask about it again.',
-                    ]
-                    : ['The shell command was not run; the agent was told you declined.'],
-                tone: 'warn',
+            if (!sticky) {
+                // The ordinary refusal records nothing at all, so there is no outcome to wait for and
+                // nothing here that core could fail to keep.
+                push({
+                    kind: 'notice',
+                    title: 'Command rejected',
+                    lines: ['The shell command was not run; the agent was told you declined.'],
+                    tone: 'warn',
+                });
+                return;
+            }
+            // [[EXT-150]] — the refusal IS in force either way (core holds it in memory whatever the file
+            // does), so only its lifetime is in question, and only core can answer that. `null` — the
+            // session ended before the answer came — is read as *not saved*, the fail-closed direction
+            // for a claim.
+            void outcome.then((landed) => {
+                const savedToProject = landed?.lifetime === 'always';
+                push({
+                    kind: 'notice',
+                    // Exactly what it does, and no more — which [[EXT-107]] makes a project file, so it also
+                    // says how to undo it. A saved refusal the user cannot find is the one failure mode
+                    // persisting it introduces, and the control that lifts it has to be named where the
+                    // refusal is made. `/approvals undeny` lists and lifts a session refusal too, so that
+                    // line is true on both branches and stays on both. The call is deliberately NOT quoted
+                    // here: a transcript notice is painted raw, and the command is the untrusted string this
+                    // whole dialog frames.
+                    title: savedToProject ? 'Command refused and saved' : 'Command refused for this session',
+                    lines: [
+                        savedToProject
+                            ? 'This exact call will be refused from now on, without asking again.'
+                            : 'This exact call will be refused for the rest of this session, without asking again.',
+                        savedToProject
+                            ? 'It is saved to this project, so it stays refused in new sessions.'
+                            : 'It was not written to the project, so a new session will ask about it again.',
+                        'Lift it with /approvals undeny, which lists what is refused and takes its number.',
+                    ],
+                    tone: 'warn',
+                });
             });
+            return;
         }
-        else {
-            const scope = decision;
-            head.resolve({ type: 'approve', scope });
-            // CFG-28 (§4.2) / EXT-70 §6 — **a scope this dialog confirms is a scope the gate will
-            // honour.** A sticky approve is reachable only where `grantPreview` is present, which the
-            // runner attaches exactly where it would store something and withholds for a `catastrophic`
-            // verdict, a command it cannot statically resolve, and a call it cannot attribute. The keys
-            // are gated on the same value in `useInput`, so there is no keystroke that arrives here
-            // asking for a persistence the store will discard — which is why this says what the pressed
-            // scope means and needs no branch for a promise that could not be kept. **The gate is what
-            // carries that, not this text:** an honest confirmation does not make an approval the menu
-            // never offered safe, because the command runs either way.
-            const describe = () => {
-                // EXT-71 §3.1 — a grant is exactly the command the human saw, so the confirmation says
-                // that and not "this operation". A longer command that merely starts with it asks again.
-                if (scope === 'session')
-                    return 'Approved — this exact command will not ask again this session.';
-                if (scope === 'always')
-                    return 'Approved and remembered — this exact command is saved to the project allow-list.';
-                return 'Approved this single invocation only.';
-            };
+        const scope = decision;
+        const outcome = head.resolve({ type: 'approve', scope });
+        // CFG-28 (§4.2) / EXT-70 §6 — **a scope this dialog confirms is a scope the gate will
+        // honour.** A sticky approve is reachable only where `grantPreview` is present, which the
+        // runner attaches exactly where it would store something and withholds for a `catastrophic`
+        // verdict, a command it cannot statically resolve, and a call it cannot attribute. The keys
+        // are gated on the same value in `useInput`, so there is no keystroke that arrives here
+        // asking for a persistence the store will discard. **The gate is what carries that, not this
+        // text:** an honest confirmation does not make an approval the menu never offered safe,
+        // because the command runs either way.
+        //
+        // [[EXT-150]] — **that argument covers `once` and `session` and stops short of `always`.** What
+        // the gate guarantees is that a control it offered has somewhere to store its answer; it says
+        // nothing about the store's file being writable, and [[EXT-149]] is the case where the offer was
+        // legitimate and the write still failed. `once` persists nothing and `session` is held in
+        // memory, so both are true the moment they are written; `always` is a claim about a file and
+        // waits for the answer below.
+        const describe = (landed) => {
+            // EXT-71 §3.1 — a grant is exactly the command the human saw, so the confirmation says
+            // that and not "this operation". A longer command that merely starts with it asks again.
+            if (landed === 'always')
+                return 'Approved and remembered — this exact command is saved to the project allow-list.';
+            if (scope === 'always')
+                return 'Approved for this session only — it was not written to the project allow-list.';
+            if (landed === 'session')
+                return 'Approved — this exact command will not ask again this session.';
+            return 'Approved this single invocation only.';
+        };
+        if (scope !== 'always') {
             push({
                 kind: 'notice',
                 title: `Command approved (${scope})`,
-                lines: [describe()],
+                lines: [describe(scope)],
                 tone: 'info',
             });
+            return;
         }
-        setApprovalQueue((q) => q.slice(1));
+        void outcome.then((landed) => {
+            const savedToProject = landed?.lifetime === 'always';
+            push({
+                kind: 'notice',
+                // The title carries a lifetime too, so it is written from the landed one for the same
+                // reason the body is — a heading saying `always` over a body saying *this session only*
+                // would be the contradiction moved up one line.
+                title: `Command approved (${savedToProject ? 'always' : 'session'})`,
+                lines: [describe(savedToProject ? 'always' : 'session')],
+                tone: 'info',
+            });
+        });
     };
     const handleSubmit = useCallback((value) => {
         if (!value.trim())
@@ -632,6 +747,8 @@ export function App(props) {
                     showApprovals();
                 else if ('trust' in result.approvals)
                     applyMcpTrust(result.approvals.trust);
+                else if ('undeny' in result.approvals)
+                    liftRefusal(result.approvals.undeny.index);
                 else
                     applyApprovalRung(result.approvals.rung);
             }
@@ -690,6 +807,7 @@ export function App(props) {
         applyApprovalRung,
         showApprovals,
         applyMcpTrust,
+        liftRefusal,
         applyMouse,
     ]);
     // Keyboard handling, in priority order:
@@ -788,6 +906,17 @@ export function App(props) {
             // reports as names, and control characters are refused outright rather than escaped: this
             // buffer is compared against one exact phrase, so anything it cannot match is better dropped
             // than repaired — and neutralising is the framing renderer's job, not a text field's.
+            //
+            // **This is the one text buffer that deliberately refuses the whole EVENT, and it does not
+            // share `keyGuards.ts`'s answer for that reason.** Everywhere else a pasted chunk keeps its
+            // text and loses its control characters, because dropping a paste over one character in it
+            // destroys what the user wrote. Here the opposite is true: a terminal delivers a pasted line
+            // as one chunk carrying its trailing `\r`, that chunk is not the Enter key, and the phrase
+            // matcher trims before it compares — so filtering the character out would leave exactly
+            // `run anyway` in the buffer, one Enter away from an irreversible command the human never
+            // typed the phrase for. A paste is the one input someone can be talked into producing
+            // without reading it, and this field's whole job is to be un-producible by accident
+            // (`spec/tui/AttackBanner.spec.tsx`, [[TUI-C68]] §1).
             if (!chord && input.length > 0 && !/[\p{Cc}]/u.test(input)) {
                 attackTypedRef.current += input;
                 setAttackTyped(attackTypedRef.current);
@@ -906,11 +1035,15 @@ export function App(props) {
                     key.pageDown) {
                     return;
                 }
-                // A chord belongs to whoever bound it, never to a text buffer — the same four modifiers the
-                // attack-banner phrase and the prompt's own editor refuse, so every buffer in the TUI reads
-                // a chord the same way. `shift` is excluded deliberately: it is how a capital is typed.
-                if (input && !key.ctrl && !key.meta && !key.super && !key.hyper) {
-                    setDebugSearch(debugSearchQueryRef.current + input);
+                // A chord belongs to whoever bound it, never to a text buffer — and neither does a bare
+                // control byte, which carries no modifier for a four-modifier guard to see. The predicate
+                // is the shared one every buffer in the TUI reads its input through (`keyGuards.ts`), so
+                // this pane and the prompt cannot disagree about what a keystroke is. What extends the
+                // query is the event's TEXT: bracketed-paste mode is off while this pane has focus (the
+                // prompt owns `usePaste` and is unmounted here), so a pasted search term arrives as one
+                // event, and a term copied off a line brings that line's newline with it.
+                if (isTypedText(input, key)) {
+                    setDebugSearch(debugSearchQueryRef.current + typedText(input, key));
                 }
                 return;
             }
@@ -1110,6 +1243,27 @@ export function App(props) {
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
+    // [[EXT-137]] — commit the request's scrollable half into the transcript, once, at the moment it
+    // becomes the one being ASKED.
+    //
+    // On the head rather than on arrival, and the difference shows only when a second call queues
+    // behind the first: printing both blocks up front would leave the dock's "the call is shown
+    // above" pointing at whichever of them the reader happened to look at, which is the one thing
+    // this split must not get wrong. It stays in the transcript afterwards, followed by the decision
+    // notice `resolveApproval` commits, so the pair reads as a record of what was asked and answered.
+    //
+    // The set is what makes it once-only. A re-render with the same head — a keystroke, a status
+    // update, a terminal resize — must not append the block again, and identity of the queue RECORD
+    // is the right key: two identical calls in a row are two records and are two questions.
+    useEffect(() => {
+        if (!pendingApproval)
+            return;
+        if (announcedApprovals.current.has(pendingApproval))
+            return;
+        announcedApprovals.current.add(pendingApproval);
+        push({ kind: 'approval', pending: pendingApproval.pending });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [pendingApproval]);
     // [[TUI-C68]] §6.1 — attack halts bridged from the runner. Each one mounts the <AttackBanner>,
     // which owns the keyboard until it is answered. Absent on the fixture path, where the runner
     // halts on its own — an unsubscribed surface keeps the halt, which is what makes forgetting to
@@ -1122,21 +1276,35 @@ export function App(props) {
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
+    // [[TUI-C69]] §5.4 — the negotiation's rounds bridged from the runner, appended as they are
+    // decided so the argument is watched while it runs rather than only reported at an escalation.
+    // Absent on the fixture path, where nothing negotiates.
+    useEffect(() => {
+        if (!props.subscribeNegotiation)
+            return;
+        return props.subscribeNegotiation((event) => {
+            // `null` is the gate saying the exchange is over. Dropping the rounds here is what stops the
+            // escalation prompt — which renders the whole argument itself — being drawn beneath a live
+            // copy of the same rounds on a screen that cannot scroll.
+            setNegotiationRounds((rounds) => (event === null ? [] : [...rounds, event]));
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
     // The greeting is an intro, not a permanent fixture: show it only before the first
     // exchange, so it stops padding the bottom dock once the conversation is underway.
     const showIntro = !initialMessage && transcript.length === 0 && !live;
     // Extract active checklist items from live turn or transcript so it stays pinned at the bottom.
     const activeChecklist = useMemo(() => extractActiveChecklist(live, transcript), [live, transcript]);
-    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 ? _jsx(LiveTurn, { turn: live, toolsExpanded: toolsExpanded, streaming: true }) : 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, 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 }) : 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) => {
                                     setApprovalsPicker(null);
                                     applyApprovalRung(rung);
-                                }, onCancel: () => setApprovalsPicker(null) })) : null, _jsx(Rule, {}), _jsx(NoticeBar, { advisories: props.advisories }), _jsx(McpFailureBar, { failures: props.mcpFailures }), _jsx(StatusBar, { running: running, mode: mode, modelDisplayName: modelDisplayName, turnCount: turnCount, debugHint: debugVisible && !debugFocused, approvals: approvals
+                                }, 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, turnCount: turnCount, debugHint: debugVisible && !debugFocused, approvals: approvals
                                     ? {
                                         rung: approvals.rung,
                                         raterProfile: approvals.rater,
                                     }
-                                    : undefined }), !debugFocused && !pendingApproval && !pendingAttack && !approvalsPicker ? (_jsx(PromptInput, { onSubmit: handleSubmit, commands: registry, onMenuStateChange: (active) => {
-                                    slashMenuActiveRef.current = active;
-                                }, handleRef: promptHandleRef })) : null, _jsx(Text, { dimColor: true, children: `${exitMessage.trim()}${TUI_HINT_SUFFIX}` }), _jsx(Rule, {})] })] }) }) }));
+                                    : undefined }), !debugFocused && !pendingApproval && !pendingAttack && !approvalsPicker ? (_jsxs(_Fragment, { children: [_jsx(BlankRow, {}), _jsx(PromptInput, { onSubmit: handleSubmit, commands: registry, onMenuStateChange: (active) => {
+                                            slashMenuActiveRef.current = active;
+                                        }, handleRef: promptHandleRef, draftCarryRef: promptDraftCarryRef }), _jsx(BlankRow, {})] })) : null, _jsx(Text, { dimColor: true, children: `${exitMessage.trim()}${TUI_HINT_SUFFIX}` }), _jsx(Rule, {})] })] }) }) }));
 }
 //# sourceMappingURL=App.js.map