@aragon-agent/cli 0.6.11 → 0.6.13

package/dist/ui/App.js

@@ -1,4 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { modelSettingsResultMessage } from '../agent/model-profile-settings.js';
+import { selectTranscriptEntries, mergePendingEntries } from '../agent/queued-messages.js';
 /**
  * App — the root Ink component. Owns the view reducer, subscribes to the
  * controller's event stream (with a streaming coalescer), wires global
@@ -18,7 +20,8 @@ import { appendPrompt, loadPromptHistory } from '../config/prompt-history.js';
 import { bumpSubmitCount, setMouseNoticeVersion, setVtInputNoticeVersion, } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 import { isTerminalStatus } from '../proc/types.js';
-import { registerSecret } from '../logging/secret-registry.js';
+import { getSecrets } from '../logging/secret-registry.js';
+import { redactText } from '../logging/redact.js';
 import { detectCapabilities } from './capabilities.js';
 import { useStartupNotices, MOUSE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
 import { getTheme } from './theme.js';
@@ -32,7 +35,6 @@ import { StatusBar } from './StatusBar.js';
 import { secondsLeft } from '../agent/retry-view.js';
 import { TeamPanel } from './TeamPanel.js';
 import { TodoPanel } from './TodoPanel.js';
-import { ActivityLine, liveSpinner } from './ActivityLine.js';
 import { BottomStatusRow } from './BottomStatusRow.js';
 import { UpdateLine } from './UpdateLine.js';
 // The updater's two PURE modules. `shouldRenderUpdateLine` decides the row's
@@ -60,7 +62,7 @@ import { publishExitSnapshot } from './exit-snapshot.js';
 import { OverlayFrame } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
-import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, readCompactionSettings, readFastSettings, } from './overlays/SettingsScreen.js';
+import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './overlays/SettingsScreen.js';
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
 import { PlanReviewOverlay } from './overlays/PlanReviewOverlay.js';
@@ -68,7 +70,11 @@ import { CommandRegistry, runSlashInput } from '../commands/registry.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
-import { copyText } from './clipboard.js';
+import { createClipboardCoordinator } from './clipboard-task.js';
+import { QueuePanel } from './QueuePanel.js';
+import { QueueOverlay } from './overlays/QueueOverlay.js';
+import { buildQueueLayout } from './layout/queue-layout.js';
+import { interactionCopy } from './interaction-copy.js';
 import { emptyTailState } from './layout/follow-state.js';
 /**
  * Decide what the `Max tokens` field means, WITHOUT letting a bad value in it
@@ -194,6 +200,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // closing an overlay cannot leave a stale offset behind, and reset whenever
     // the active overlay changes.
     const [overlayScroll, setOverlayScroll] = useState(0);
+    const [completion, setCompletion] = useState('none');
+    const [copyState, setCopyState] = useState({ busy: false, cleanupPending: false });
     // Bumped whenever the installed skill set changes. The command registry and
     // the completion list are memoized against it, so a skill installed mid-session
     // gets its `/<name>` command and its autocomplete entry immediately.
@@ -433,6 +441,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // makes stale events inert WITHOUT making the next run's events inert too.
         let generation = controller.runGeneration;
         const unsubscribe = controller.subscribe((event) => {
+            // Receipts describe committed history even when force-stop invalidated the run.
+            if (event.type === 'steering_accepted') {
+                dispatch({ type: 'steeringAccepted', ids: event.ids });
+                return;
+            }
             if (controller.runGeneration !== generation) {
                 // The engine is unwinding a force-stopped run. Adopt the new generation
                 // only once it has finished doing so, so a late `agent_end` cannot be
@@ -937,7 +950,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // --- Exit snapshot: the only way state reaches cli.tsx (§4.4). ----------
     useEffect(() => {
         publishExitSnapshot({
-            entries: state.entries,
+            entries: mergePendingEntries(state.entries, state.pendingSteering),
             usageTotal: state.usageTotal,
             provider: cfg.provider,
             model: cfg.model,
@@ -947,7 +960,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // count (K-6).
             droppedEntries: state.droppedEntries,
         });
-    }, [state.entries, state.usageTotal, state.droppedEntries, cfg.provider, cfg.model]);
+    }, [state.entries, state.pendingSteering, state.usageTotal, state.droppedEntries, cfg.provider, cfg.model]);
     // --- `/perf` snapshot channel (tui-render-performance §5.4). ------------
     //
     // The deps are the two `useCallback`d members, NOT the handle objects: both
@@ -1161,22 +1174,36 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // redraw when the frame differ has no cache to repaint from. Both are assigned
     // here and cleared on unmount, the same shape `updateBridge` uses.
     const selectionBridge = terminal?.selection;
+    const copyCoordinator = useMemo(() => createClipboardCoordinator({
+        clipboard: { write: terminal?.writeForeign },
+        onRequest: () => {
+            ctrlCArmed.current = false;
+            if (ctrlCTimer.current)
+                clearTimeout(ctrlCTimer.current);
+            ctrlCTimer.current = null;
+        },
+        onStateChange: setCopyState,
+        onBusy: ({ cleanupPending }) => toast('info', cleanupPending
+            ? '\u590d\u5236\u5931\u8d25\uff0c\u6b63\u5728\u6e05\u7406' : '\u6b63\u5728\u590d\u5236'),
+        onResult: (result, request) => {
+            selectionBridge?.onCopied?.(result, request.lines, request.text.length);
+            if (result.status === 'confirmed') {
+                toast('success', `\u5df2\u590d\u5236 ${request.lines} \u884c`);
+            }
+            else if (result.status === 'sent') {
+                toast('info', '\u5df2\u8bf7\u6c42\u7ec8\u7aef\u590d\u5236\uff0c\u7ed3\u679c\u672a\u786e\u8ba4');
+            }
+            else {
+                const text = `${interactionCopy.copyFailed}\uff1a${interactionCopy.copyReasons[result.reason]}`;
+                toast('warn', text);
+                notify('error', text);
+            }
+        },
+    }), []);
+    useEffect(() => () => copyCoordinator.dispose(), [copyCoordinator]);
     useEffect(() => {
         if (!selectionBridge)
             return undefined;
-        selectionBridge.onCopied = (via, lines, chars) => {
-            // IT NAMES THE MECHANISM RATHER THAN CLAIMING SUCCESS (R-7). Neither OSC 52
-            // nor a spawned `xclip` is detectable: tmux without `set -g set-clipboard
-            // on` swallows the first silently, and the second is best-effort by
-            // construction. A toast that said "copied successfully" would be guessing.
-            const noun = lines === 1 ? 'line' : 'lines';
-            if (via === 'none') {
-                toast('warn', 'Nothing could be copied - no clipboard mechanism is available.');
-                return;
-            }
-            const how = via === 'osc52' ? 'terminal clipboard' : 'system clipboard';
-            toast('success', `Sent ${lines} ${noun} (${chars} chars) to the ${how}.`);
-        };
         // I-5 of `frame-differ.ts`: writing escapes here would be a foreign write.
         // The nonce is the carrier Ctrl+L already uses (§4.13).
         selectionBridge.requestRedraw = () => setRedrawNonce((n) => n + 1);
@@ -1283,6 +1310,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     };
     const makeCtx = (args) => ({
         args,
+        requestCopy: copyCoordinator.requestCopy,
         controller,
         state: stateRef.current,
         dispatch: (action) => {
@@ -1306,7 +1334,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         toast,
         persistConfig,
         exit: doExit,
-        submit: (text, opts) => submitMessage(text, opts),
+        submit: (text, opts) => {
+            const result = submitMessage(text, opts);
+            if (!result.accepted)
+                throw new Error(result.reason ?? 'Message was not accepted.');
+        },
         refreshSkills: () => setSkillsNonce((n) => n + 1),
         applyAgentMode: applyMode,
         // Read at command time, so `/todo status` reports the live count rather than
@@ -1361,28 +1393,33 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
      * start with `/`, recurse into command dispatch.
      */
     const submitMessage = (message, opts = {}) => {
+        if (controller.getConfig().modelSettingsRestartRequired) {
+            return { accepted: false, reason: 'Settings require a restart before sending requests.' };
+        }
+        if (interactionPhase.current === 'starting') {
+            return { accepted: false, reason: 'A run is still starting. Press Esc twice to cancel.' };
+        }
         // A USER MESSAGE IS A NEW INTENT AND OUTRANKS A QUEUED ONE (AC-19). First
         // line, before the steering branch: a message typed during the grace window
         // must be the one that runs, whichever branch it takes.
         cancelFollowThrough();
         cancelConfirmation();
         if (interactionPhase.current === 'running') {
-            controller.steer(message);
-            // THE TRANSCRIPT ENTRY IS THE FEEDBACK (tui-shift-enter-copy-queue
-            // 5.3). A 2.5 s toast cannot satisfy "until the message is picked
-            // up": the `queued` entry stays visible and is rewritten in place
-            // as the user message it became on the next `turn_start`. Keeping
-            // the toast too would confirm one event twice.
-            dispatch({ type: 'steerQueued', text: message });
-            return;
-        }
-        if (interactionPhase.current === 'starting') {
-            toast('info', 'A run is still starting. Press Esc twice to cancel.');
-            return;
+            try {
+                const queueId = controller.queueUserMessage(message);
+                dispatch({ type: 'steerQueued', queueId, text: message });
+                return { accepted: true };
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                notify('error', reason);
+                return { accepted: false, reason };
+            }
         }
         resetInterrupt();
         const sequence = ++submissionSequence.current;
         interactionPhase.current = 'starting';
+        dispatch({ type: 'runStarting' });
         // `userInitiated: false` skips TWO things and both are wanted: the
         // prompt-history append, and the `submitCount` bump that drives the
         // composer's hint fade. An auto-continuation demonstrates nothing about what
@@ -1396,12 +1433,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         dispatch({ type: 'submit', text: message });
         const pre = controller.preflight();
         if (!pre.ok) {
+            dispatch({ type: 'runError' });
             notify('error', pre.message ?? 'Configuration error.');
             interactionPhase.current = 'idle';
             resetInterrupt();
             autoContinuationRef.current = false;
             dispatch({ type: 'runEnd' }); // reset status; nothing was started
-            return;
+            return { accepted: true };
         }
         // Fire-and-forget: events drive the UI. prompt() never rejects.
         void controller.prompt(message, { todoPolicy: opts.todoPolicy ?? 'new-task' }).then((outcome) => {
@@ -1409,110 +1447,63 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 return;
             if (outcome?.status !== 'not-started')
                 return;
+            if (outcome.reason !== 'cancelled')
+                dispatch({ type: 'runError' });
             interactionPhase.current = 'idle';
             resetInterrupt();
             autoContinuationRef.current = false;
             dispatch({ type: 'runEnd' });
         });
+        return { accepted: true };
     };
     submitRef.current = submitMessage;
-    const handleSubmit = async (raw) => {
-        if (interactionPhase.current === 'running' && /^\s*\/(reset|resume)(?:\s|$)/.test(raw)) {
-            notify('warn', 'Interrupt the current run before switching conversations.');
-            return;
+    const executeSlashInput = async (raw) => {
+        // Retain a recoverable command before any asynchronous handler can fail.
+        const safe = redactText(raw, getSecrets());
+        recordPrompt(safe);
+        notify('info', `Command: ${safe}`);
+        try {
+            await runSlashInput(registry, raw, makeCtx);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            notify('error', `Command failed: ${redactText(reason, getSecrets())}\nInput: ${safe}`);
+        }
+    };
+    const handleSubmit = (raw) => {
+        const trimmed = raw.trimStart();
+        const slash = trimmed.startsWith('/') && !trimmed.startsWith('//');
+        if (slash && (interactionPhase.current === 'running' || controller.isRunning()) &&
+            /^\/(reset|resume)(?:\s|$)/.test(trimmed)) {
+            return { accepted: false,
+                reason: 'Interrupt the current run before switching conversations.' };
         }
         // Submitting is an unconditional "take me to the newest output" (§4.5).
         setPinToBottomNonce((n) => n + 1);
-        const handled = await runSlashInput(registry, raw, makeCtx);
-        if (handled)
-            return;
-        submitMessage(raw.startsWith('//') ? raw.slice(1) : raw);
+        if (slash) {
+            void executeSlashInput(raw);
+            return { accepted: true };
+        }
+        return submitMessage(trimmed.startsWith('//') ? raw.replace('//', '/') : raw);
     };
-    const handleSettingsSave = (values) => {
-        // An unusable cap must NOT discard the rest of the form: the same Enter
-        // press is often carrying a freshly pasted API key, and losing that to a
-        // typo in an unrelated field is the worst outcome available here.
-        const cap = resolveSettingsMaxTokens(values.maxTokens, controller.getConfig().maxTokens);
-        controller.setModel(values.provider, values.model, values.baseUrl || undefined);
-        controller.setThinkingLevel(values.thinkingLevel);
-        controller.setMaxTokens(cap.applied);
-        // THE SETTER AND THE PERSIST ARE BOTH REQUIRED, the pair `/todo panel`
-        // documents: persisting alone reports success and changes nothing until the
-        // next launch. `thinkingVisible` lives in `ViewState`, not in the config the
-        // controller holds, so the live half is a dispatch rather than a setter —
-        // and it is a no-op when the row already agrees with the current state.
-        if ((values.showThinking === 'on') !== stateRef.current.thinkingVisible) {
+    const handleProfileSave = (draft) => {
+        const result = controller.saveModelSettings(draft);
+        if (!result.ok)
+            return result;
+        if (draft.patch.showThinking !== undefined
+            && controller.getConfig().showThinking !== stateRef.current.thinkingVisible) {
             dispatch({ type: 'toggleThinking' });
         }
-        const key = values.apiKey.trim();
-        if (key.length > 0) {
-            // Registration site 4 (§4.4.3), and the one that matters most: this is how
-            // a key most often enters the process, and it happens long after
-            // `installLogging()` ran. A startup snapshot would miss it entirely, and
-            // the vendor regexes only cover keys that look like a vendor's.
-            registerSecret(key);
-            controller.setApiKey(values.provider, key);
-        }
-        const patch = {
-            provider: values.provider,
-            model: values.model,
-            baseUrl: values.baseUrl.trim() ? values.baseUrl.trim() : null,
-            thinkingLevel: values.thinkingLevel,
-            showThinking: values.showThinking === 'on',
-            // PERSIST ONLY, with no paired live setter — the store is allocated in
-            // `AgentController`'s constructor, so this row takes effect on the next
-            // launch. That is what manual row 8 asks for, and it is why the seed above
-            // reads `cfg` rather than `ViewState`.
-            liveToolOutput: values.liveToolOutput === 'on',
-            // Omitted entirely when the field was unusable, so the previous value
-            // survives instead of being overwritten with a guess.
-            ...(cap.persist !== 'skip' ? { maxTokens: cap.persist } : {}),
-        };
-        if (key.length > 0)
-            patch.apiKeys = { [values.provider]: key };
-        // A PARTIAL `log` section, safe only because `updatePersistedConfig` deep-
-        // merges it — a shallow merge here would reset `redactSecrets` every time
-        // someone touched the level.
-        patch.log = { level: values.logLevel };
-        // --- Fast tier (fast-model-tier §4.5) ---------------------------------
-        //
-        // THE SETTER AND THE PERSIST ARE BOTH REQUIRED, and this is the pair `/todo
-        // panel` documents (P1-2): `App` reads `controller.getConfig()` at render
-        // time, so persisting alone reports success and changes nothing until the
-        // next launch, while the setter alone forgets by morning.
-        //
-        // `setFastConfig` also re-resolves the tier, which matters HERE more than
-        // anywhere: this same Enter press may have changed the main provider, the
-        // main model or the API key, and `fast.provider: ''` inherits from all
-        // three (§3.2 rule 8 / RV-3).
-        const fastPatch = readFastSettings(values);
-        controller.setFastConfig(fastPatch);
-        patch.fast = fastPatch;
-        // --- Context compaction (context-auto-compaction §4.5) ------------------
-        //
-        // THE SAME SETTER-AND-PERSIST PAIR, and the same reason. `setCompactionConfig`
-        // additionally re-emits the snapshot, which is what moves the status chip and
-        // the gauge's marks without waiting for the next turn.
-        //
-        // `enabled` here flips the LIVE switch only. Whether the wiring exists at all
-        // was decided at construction and cannot be undone in this session (§3.2), so
-        // a user who turns it ON in a `--no-compaction` session gets the persisted
-        // value for next launch and nothing this session — which is exactly what
-        // `/compact on` reports in words.
-        const compactionPatch = readCompactionSettings(values);
-        controller.setCompactionConfig(compactionPatch);
-        if (compactionPatch.enabled !== undefined) {
-            controller.setCompactionEnabled(compactionPatch.enabled);
-        }
-        patch.compaction = compactionPatch;
-        persistConfig(patch);
-        getLogger().reconfigure({ ...controller.getConfig().log, level: values.logLevel });
         dispatch({ type: 'setOverlay', overlay: null });
-        toast(cap.toast?.[0] ?? 'success', cap.toast?.[1] ?? 'Settings saved.');
+        toast(result.restartRequired ? 'warn' : 'success', modelSettingsResultMessage(result));
+        return result;
     };
     const handleModelSelect = (provider, model) => {
-        controller.setModel(provider, model);
-        persistConfig({ provider, model });
+        const result = controller.saveModelSettingsPatch({ provider, model });
+        if (!result.ok) {
+            toast('error', modelSettingsResultMessage(result));
+            return;
+        }
         dispatch({ type: 'setOverlay', overlay: null });
         toast('info', `Model set to ${provider}:${model}.`);
     };
@@ -1619,15 +1610,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // (`via === 'none'`) still reports through the shared toast funnel and
         // returns: the selection is already consumed, and the NEXT Ctrl+C
         // walks the original ladder.
+        if (key.ctrl && (input === 'c' || input === 'C') && copyCoordinator.isBusy()) {
+            void copyCoordinator.requestCopy({ text: '', lines: 0 });
+            return;
+        }
         if (key.ctrl &&
             (input === 'c' || input === 'C') &&
             (selectionController?.hasPendingSelection() ?? false)) {
             const payload = selectionController.takeSelection();
+            ctrlCArmed.current = false;
+            if (ctrlCTimer.current)
+                clearTimeout(ctrlCTimer.current);
+            ctrlCTimer.current = null;
             if (payload) {
-                const via = copyText(payload.text, terminal?.writeForeign);
-                selectionBridge?.onCopied?.(via, payload.lines, payload.text.length);
-                return; // copied -- no service stop, no arm, no clear
+                void copyCoordinator.requestCopy({ text: payload.text, lines: payload.lines });
             }
+            return; // A consumed copy intent never becomes exit or service stop.
         }
         selectionController?.clear();
         if (key.ctrl && (input === 'c' || input === 'C')) {
@@ -1672,7 +1670,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const overlay = stateRef.current.overlay;
             // Modes A only. `model` / `confirm` manage their own keys; registering an
             // arrow handler for them would double every keypress (R-12).
-            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan';
+            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan' || overlay === 'queue';
             if (key.pageUp) {
                 if (controlled)
                     setOverlayScroll((n) => Math.max(0, n - OVERLAY_PAGE));
@@ -1687,7 +1685,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // worth more than scrolling six fields (§4.9). `question` keeps them for
             // its option cursor, for the same reason; `plan` has no cursor of its own
             // and scrolls a line at a time.
-            if ((overlay === 'help' || overlay === 'plan') && (key.upArrow || key.downArrow)) {
+            if ((overlay === 'help' || overlay === 'plan' || overlay === 'queue') && (key.upArrow || key.downArrow)) {
                 setOverlayScroll((n) => Math.max(0, n + (key.upArrow ? -1 : 1)));
                 return;
             }
@@ -1782,6 +1780,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         }
         if (key.escape) {
             const overlay = stateRef.current.overlay;
+            if (overlay === 'settings')
+                return;
             if (overlay) {
                 cancelConfirmation();
                 if (overlay === 'confirm' && confirmRef.current) {
@@ -1816,7 +1816,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         interruptGesture.current = next.state;
         if (next.action === 'hint') {
             dispatch({ type: 'pushToast', level: 'info',
-                text: 'Press Esc again within 1.5s to interrupt.' });
+                text: '\u4e2d\u65ad\u5df2\u51c6\u5907' });
             return;
         }
         endReasonRef.current.aborted = true;
@@ -1837,7 +1837,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         controller.abort();
         if (sequence === submissionSequence.current && interactionPhase.current === 'running') {
             dispatch({ type: 'pushToast', level: 'info',
-                text: 'Interrupt requested. Esc again to force-stop.' });
+                text: '\u6b63\u5728\u505c\u6b62' });
         }
     }, [controller, cancelFollowThrough, resetInterrupt]);
     // --- Render ------------------------------------------------------------
@@ -1848,6 +1848,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // which is what lets the user's `contextWindow` override reach the gauge at
     // all. Nothing else in this render read them.
     const overlay = state.overlay;
+    const settingsDraft = useMemo(() => overlay === 'settings'
+        ? controller.createModelSettingsDraft() : undefined, [controller, overlay]);
     const hasKey = controller.hasApiKey();
     const empty = state.entries.length === 0;
     // RENDER SCOPE, so the chip and the composer hint agree with what the Ctrl+C
@@ -1896,24 +1898,28 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const nowSec = running || compactionLive ? Math.floor(Date.now() / 1000) : undefined;
     const viewportBudget = computeViewportRows(rows, draftRows);
     const overlayMaxRows = viewportBudget;
-    // Renderers consume these same projections. Team capacity does not depend on
-    // popup occupancy, so a menu cannot toggle the team's collapsed state.
-    // THE ONE CONDITION for "the hint row exists": it sizes the footer below AND
-    // decides whether the run status row may replace that hint row while running,
-    // so starting a run can never add or remove a footer row.
-    const hintRowEnabled = rows >= HINT_MIN_ROWS && cfg.hints;
-    const composerBaseRows = 2 + clampDraftRows(rows, draftRows) + Number(hintRowEnabled);
+    const composerBaseRows = 2 + clampDraftRows(rows, draftRows);
+    const baseRail = buildTodoRailLayout({
+        cols: cols - 1, panelEnabled: cfg.todo.panel, overlayOpen: false,
+        itemCount: state.todos?.items.length ?? 0, viewportBudget,
+        teamRows: 0, popupRows: 0, composerBaseRows,
+    });
+    const queueLayout = useMemo(() => buildQueueLayout({
+        pending: state.pendingSteering, columns: baseRail.contentCols, terminalRows: rows,
+        availableRows: Math.max(0, viewportBudget - composerBaseRows - 1), paused: !running,
+    }), [state.pendingSteering, baseRail.contentCols, rows, viewportBudget, composerBaseRows, running]);
     const teamLayout = buildTeamPanelLayout({
-        snapshot: state.team, terminalRows: rows, availableRows: Math.max(0, viewportBudget - composerBaseRows),
+        snapshot: state.team, terminalRows: rows,
+        availableRows: Math.max(0, viewportBudget - composerBaseRows - queueLayout.rows - 1),
     });
     const railLayout = buildTodoRailLayout({
         cols: cols - 1, panelEnabled: cfg.todo.panel, overlayOpen: false,
         itemCount: state.todos?.items.length ?? 0, viewportBudget,
-        teamRows: teamLayout.rowCount, popupRows, composerBaseRows,
+        teamRows: teamLayout.rowCount, queueRows: queueLayout.rows, popupRows, composerBaseRows,
     });
-    // Transcript and composer share contentCols; fixed chrome and overlays use terminal width.
     const { visible: showRail, width: railWidth, rows: railRows, contentCols } = railLayout;
-    const overlayNode = overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: cols, rows: helpRows(theme, caps), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'settings' ? (_jsx(SettingsScreen, { initial: {
+    const transcriptEntries = useMemo(() => selectTranscriptEntries(state.entries, state.pendingSteering), [state.entries, state.pendingSteering]);
+    const overlayNode = overlay === 'queue' ? (_jsx(QueueOverlay, { pending: state.pendingSteering, cols: cols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: cols, rows: helpRows(theme, caps), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'settings' ? (_jsx(SettingsScreen, { initial: {
             provider: cfg.provider,
             model: cfg.model,
             baseUrl: cfg.baseUrl ?? '',
@@ -1942,7 +1948,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // the save handler cannot disagree about what `(inherit)` means.
             ...fastSettingsFrom(cfg.fast),
             ...compactionSettingsFrom(cfg.compaction),
-        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onSave: handleSettingsSave, 
+        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
         // Read from `cfg` (render scope, re-read every frame), so `/retry off`
         // while the screen is open shows the new value on the next paint.
         retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { state: confirmState, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { questions: humanRequest.questions, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { plan: humanRequest.plan, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
@@ -1953,61 +1959,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const opener = empty ? (_jsx(SessionOpener, { variant: pickOpenerVariant(viewportBudget, contentCols, caps), version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: viewportBudget, theme: theme, caps: caps })) : null;
     const density = cfg.density;
     const transcriptWindow = cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW;
-    // --- One spinner per run (single-spinner-while-running D-1 .. D-5). ------
-    //
-    // THE MOUNT CONDITION, NAMED ONCE AND USED TWICE (D-4). This const both gates
-    // the `<ActivityLine>` element below and feeds the derivation on the next
-    // line, so "the line is up" and "every other site is still" can never
-    // disagree. Two copies of the same boolean expression is exactly how that
-    // invariant becomes false in six months, silently and in only one branch.
-    //
-    // NOT `running` ALONE (D-3). While an overlay owns the screen the activity row
-    // is suppressed, so keying suppression off `running` would leave the frame
-    // with ZERO life signals: the bar shows state, this row shows life. Never
-    // trade one duplicate for one absence.
-    //
-    // THE CLAIM ABOVE WAS ONCE FALSE, AND THAT WAS THE WHOLE OF
-    // `activity-spinner-vanishes-behind-toast`. `BottomStatusRow` — not this const
-    // — decides what the row actually shows, and a toast used to take the row
-    // outright, so for its 2.5 s TTL this said "the line is up" while nothing was
-    // mounted and all seven other sites sat still. The answer was NOT to enumerate
-    // `&& !state.toasts.length` here (the next occupant reopens it, and the seven
-    // sites animating out of phase is the defect this whole feature removed):
-    // `BottomStatusRow` now carries the bare spinner alongside the toast, so the
-    // signal is mounted exactly when this const is true and the claim holds by
-    // construction.
-    const activityVisible = running && !overlayNode;
-    // The FOUR VIEW CONSUMERS (transcript x 2, team panel, todo panel) take this;
-    // the activity line keeps the raw config flag (D-5), because it reads that
-    // flag a second time to gate phrase rotation and the widened value would
-    // freeze the phrase at the first word of every run.
-    //
-    // So below `App` the prop now means "this frame does not animate here" rather
-    // than "the user asked for reduced motion". `cfg.reducedMotion` (`:279`) stays
-    // the sole config source, and `spinner-census.test.ts` pins this wiring —
-    // threading the raw flag into a fifth consumer is the one silent way back to
-    // two spinners (R-2).
-    const viewReducedMotion = reducedMotion || activityVisible;
-    // The run status row (spinner + phrase + queue/interrupt hint) replaces the idle
-    // hint row ABOVE the input while running; it exists only when that hint row
-    // would, so the footer height is identical with and without it. `running`, not
-    // `activityVisible`: an overlay must not flip the Composer between two layouts.
-    const runRowEnabled = running && hintRowEnabled;
-    // The raw `reducedMotion` flag lives here and nowhere else (D-5).
-    const runActivity = {
-        startedAt: runStartedAt.current,
-        elapsedMs,
-        reducedMotion,
-        runningTool,
-        // THE ROW MUST NEVER SAY SOMETHING FALSE (§6.1). Compaction runs BEFORE
-        // `turn_start`, so `status` is `'running'` with no tool in flight - precisely
-        // the window in which the rotating phrase would claim the model is thinking
-        // while it is actually waiting on a 30k-token summarization.
-        compacting: state.compaction?.inFlight === true,
-    };
-    // The fixed bottom row takes over the life signal once the run row scrolls out
-    // of the viewport; exactly one of the two ever animates.
-    const runRowShown = runRowEnabled && activityRowVisible;
+    // The fixed status bar remains visible underneath every overlay and toast.
+    const viewReducedMotion = reducedMotion || running || state.runPhase === 'starting' || compactionLive;
     // Assigned during render so `/perf` reads the CURRENT frame (see `perfRef`).
     // `mountedEntries` is the same number `render-budget.test.tsx` asserts (AC-9).
     perfRef.current = {
@@ -2044,39 +1997,21 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // Both keys always WORK (they share one branch in the input handler); this
     // only decides which one the user is taught.
     const modeToggleKey = vtInputWarning ? MODE_TOGGLE_KEYS.fallback : MODE_TOGGLE_KEYS.primary;
-    const composer = (_jsx(Composer, { measureRef: composerRef, runRow: runRowEnabled
-            ? { activity: runActivity, live: runRowShown && !overlayNode, rowRef: activityRef }
-            : null, cols: contentCols, cursorVisible: cursorVisible, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: railLayout.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, scrolledLines: scrolledLines, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
+    const composer = (_jsx(Composer, { measureRef: composerRef, deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: contentCols, cursorVisible: cursorVisible, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: railLayout.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, scrolledLines: scrolledLines, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
     const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const rail = showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
-    const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: tooSmall ? null : overlayNode, footer: _jsxs(_Fragment, { children: [team, composer] }), rail: rail, scrollbar: terminal?.scrollbar, composerRef: composerRef, onComposerVisibilityChange: setCursorVisible, activityRef: activityRef, onActivityVisibilityChange: setActivityRowVisible, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
-    return (_jsx(AppShell, { inactive: tooSmall, placeholder: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least 40 columns and 12 rows."] }), rows: rows, cols: cols, header: header, viewport: viewport, toast: _jsx(BottomStatusRow, { toasts: state.toasts, activity: activityVisible && !runRowShown ? (_jsx(ActivityLine, { ...runActivity, theme: theme, caps: caps })) : null, 
-            // THE FORM THE LIFE SIGNAL TAKES WHEN A TOAST HAS THE ROW
-            // (`activity-spinner-vanishes-behind-toast`). Passed UNCONDITIONALLY:
-            // `BottomStatusRow` reads it only when `activity` above is non-null,
-            // so `activityVisible` stays the one mount condition and this cannot
-            // become a second copy of it that drifts. `null` here means the
-            // spinner would be static anyway (ASCII tier, or reduced motion), and
-            // those builds must come out unchanged.
-            activityGlyph: liveSpinner(reducedMotion, caps), 
-            // PRESENCE IS DECIDED HERE, NOT BY `UpdateLine` RETURNING `null`
-            // (C-15 / cli-auto-update P0-1 / D-19). `BottomStatusRow` tests this
-            // prop for truthiness, and a React element is truthy however it
-            // renders - so a component that rendered nothing would give the row
-            // ZERO rows and silently unbalance the frame budget. Same rule the
-            // activity line above follows with `running && !overlayNode`.
-            //
-            // `!overlayNode` for the same reason it appears there: the full-screen
-            // branch replaces the whole viewport with the overlay, and an update
-            // notice under a settings screen is noise attached to a surface it is
-            // not visible on.
-            //
-            // `!running` (cli-auto-update D-2): the update notice stays silent for
-            // the whole run. It used to be guaranteed by the activity line
-            // out-ranking it inside this row; with the activity line moved above
-            // the input, the row can be free during a run, so the silence is stated
-            // here instead of inherited.
-            update: updateSnapshot && !overlayNode && !running && shouldRenderUpdateLine(updateSnapshot) ? (_jsx(UpdateLine, { snapshot: updateSnapshot, compact: cols < UPDATE_LIMITS.statusCompactCols, theme: theme, caps: caps })) : null, theme: theme }), status: _jsx(StatusBar, { interruptHint: interruptGesture.current.phase === 'stopping'
+    const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: tooSmall ? null : overlayNode, footer: _jsxs(_Fragment, { children: [team, _jsx(QueuePanel, { layout: queueLayout, theme: theme }), composer] }), rail: rail, scrollbar: terminal?.scrollbar, composerRef: composerRef, onComposerVisibilityChange: setCursorVisible, activityRef: activityRef, onActivityVisibilityChange: setActivityRowVisible, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: transcriptEntries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
+    return (_jsx(AppShell, { inactive: tooSmall, placeholder: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least 40 columns and 12 rows."] }), rows: rows, cols: cols, header: header, viewport: viewport, toast: _jsx(BottomStatusRow, { toasts: state.toasts, hints: { interactionPhase: state.runPhase === 'starting' ? 'starting'
+                    : running ? 'running' : 'idle', cols, completion,
+                selectionPending: selectionController?.hasPendingSelection() ?? false,
+                copyInFlight: copyState.busy, copyCleanupPending: copyState.cleanupPending,
+                overlay, services: liveServices, hintsEnabled: cfg.hints, modeToggleKey,
+                interruptHint: interruptGesture.current.phase === 'stopping'
+                    ? 'Esc force-stop' : interruptGesture.current.phase === 'armed'
+                    ? 'Esc confirm' : 'Esc x2 interrupt',
+                updateAvailable: !!updateSnapshot && !overlayNode && !running
+                    && shouldRenderUpdateLine(updateSnapshot),
+            }, update: updateSnapshot && !overlayNode && !running && shouldRenderUpdateLine(updateSnapshot) ? (_jsx(UpdateLine, { snapshot: updateSnapshot, compact: cols < UPDATE_LIMITS.statusCompactCols, theme: theme, caps: caps })) : null, theme: theme }), status: _jsx(StatusBar, { pendingSteering: state.pendingSteering, runPhase: state.runPhase, activeTool: state.activeTool, runOutcome: state.runOutcome, reducedMotion: reducedMotion, waitingForConfirmation: !!humanRequest || !!confirmState, stopping: interruptGesture.current.phase === 'stopping', interruptHint: interruptGesture.current.phase === 'stopping'
                 ? 'Esc force-stop' : 'Esc x2 interrupt', model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, 
             // ONE OBJECT INSTEAD OF FOUR PARALLEL PROPS (§4.3). The four were a
             // projection of "many sources of truth" into the props layer, and a