@namzu/cli 14.1.0 → 14.2.1

package/dist/tui/App.js

@@ -19,7 +19,7 @@ import { pinTrustedProjectPath, resolveTrustedProjectContext, } from '../config/
 import { visibleProjectInstructionPath } from '../context/project-path.js';
 import { writeClipboardText } from '../integrations/clipboard/text.js';
 import { terminalNotificationEnabled, writeTerminalNotification, } from '../integrations/notifications/terminal.js';
-import { beginCodexDeviceLogin, beginSubscriptionLogin, clearAllStoredCredentials, credentialsPath, primaryProvider, readStoredCodexCredential, readStoredSubscriptionCredential, signedInSubscriptionProviders, writePreferences, } from '../integrations/providers/index.js';
+import { beginCodexDeviceLogin, beginSubscriptionLogin, clearAllStoredCredentials, credentialsPath, parsePastedInput, primaryProvider, readStoredCodexCredential, readStoredSubscriptionCredential, signedInSubscriptionProviders, writePreferences, } from '../integrations/providers/index.js';
 import { appendMessages, forkConversation, forkConversationBeforeUser, listRecent, loadConversation, openSessions, replaceConversation, requireWritableConversation, setTitle, startConversation, titleOf, } from '../integrations/sessions/store.js';
 import { conversationMarkdown, writeConversationExport, } from '../integrations/sessions/transcript-export.js';
 import { isTrusted, trustDir } from '../integrations/trust/store.js';
@@ -27,6 +27,7 @@ import { checkUpdates } from '../integrations/updates.js';
 import { appendMemory, composeMemoryPrompt, readMemory } from '../memory/store.js';
 import { composeSkillsPrompt, discoverSkills, loadSkillBody } from '../skills/store.js';
 import { discoverUserCommands } from '../user-commands/store.js';
+import { ChoicePicker } from './ChoicePicker.js';
 import { Composer } from './Composer.js';
 import { CopyPicker } from './CopyPicker.js';
 import { EditPromptPicker } from './EditPromptPicker.js';
@@ -42,7 +43,7 @@ import { bottomSpacerRows } from './bottom-spacer.js';
 import { keepRecentRows } from './compact-transcript.js';
 import { approvalIsDeliberate } from './consent-timing.js';
 import { planTurnPublication } from './conversation-history.js';
-import { copyTargetsForResponse, } from './copy-targets.js';
+import { copyTargetsForResponse } from './copy-targets.js';
 import { editablePrompts } from './edit-prompts.js';
 import { liveWindow, transcriptLines } from './live-window.js';
 import { describeCodexDeviceLoginStart, describeLoginOutcome, describeLoginStart, describeLogout, } from './login-prompt.js';
@@ -328,6 +329,14 @@ export function App({ ctx: initialCtx }) {
         copyPickerRef.current = next;
         setCopyPickerState(next);
     }, []);
+    /** Finite slash-command choice owned synchronously until apply or cancel. */
+    const [choicePicker, setChoicePickerState] = useState(null);
+    const choicePickerRef = useRef(null);
+    const [selectedChoice, setSelectedChoice] = useState(0);
+    const setChoicePicker = useCallback((next) => {
+        choicePickerRef.current = next;
+        setChoicePickerState(next);
+    }, []);
     const [composerDraft, setComposerDraft] = useState(null);
     const composerDraftTokenRef = useRef(0);
     const exitArmedRef = useRef(false);
@@ -399,6 +408,7 @@ export function App({ ctx: initialCtx }) {
     const [goalActivation] = useState(() => new SessionGoalActivation());
     const goalDriveInFlightRef = useRef(false);
     const [goalDriveVersion, setGoalDriveVersion] = useState(0);
+    const [goalStatus, setGoalStatus] = useState(null);
     const wakeGoalDriver = useCallback(() => setGoalDriveVersion((version) => version + 1), []);
     /**
      * Conversation writes in the order the operator produced them.
@@ -517,6 +527,70 @@ export function App({ ctx: initialCtx }) {
         ]);
         return id;
     }, [nextId]);
+    const applyPermissionMode = useCallback((mode) => {
+        if (!session?.hasProvider) {
+            pushMessage('system', 'No active session — pick a provider before changing permissions.');
+            return;
+        }
+        if (state !== 'idle' ||
+            abortRef.current !== null ||
+            hasUnsettledTurn() ||
+            queuedRef.current.length > 0 ||
+            permissionResolveRef.current !== null ||
+            compactingRef.current) {
+            pushMessage('system', 'Permission mode was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
+            return;
+        }
+        if (!session.resetApprovalLatch) {
+            pushMessage('system', 'Permission mode was not changed: this embedded session cannot revoke an earlier "approve all" choice. Reconnect it before changing modes.');
+            return;
+        }
+        session.resetApprovalLatch();
+        permissionModeRef.current = mode;
+        permissionModeSourceRef.current = 'session';
+        setPermissionModeState(mode);
+        pushMessage('system', `Permission mode changed to ${mode}. Any earlier "approve all" choice was revoked. Declarative deny rules and the built-in safety gate still take precedence.`);
+    }, [hasUnsettledTurn, pushMessage, session, state]);
+    const applyReasoningEffort = useCallback((effort) => {
+        if (!session?.hasProvider) {
+            pushMessage('system', 'No active session — pick a provider before changing reasoning effort.');
+            return;
+        }
+        if (state !== 'idle' ||
+            abortRef.current !== null ||
+            hasUnsettledTurn() ||
+            queuedRef.current.length > 0 ||
+            permissionResolveRef.current !== null ||
+            compactingRef.current) {
+            pushMessage('system', 'Reasoning effort was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
+            return;
+        }
+        if (effort === undefined) {
+            setReasoningEffort(undefined);
+            pushMessage('system', 'Reasoning effort reset to the provider default for future main-query turns.');
+            return;
+        }
+        if (!session.reasoningEffortLevels?.includes(effort)) {
+            pushMessage('system', `Reasoning effort was not changed: ${effort} is not offered by every usable provider-chain member for this model.`);
+            return;
+        }
+        setReasoningEffort(effort);
+        pushMessage('system', `Reasoning effort changed to ${effort} for future main-query turns in this session.`);
+    }, [hasUnsettledTurn, pushMessage, session, setReasoningEffort, state]);
+    const applyChoiceSelection = useCallback((index) => {
+        const picker = choicePickerRef.current;
+        if (!picker)
+            return;
+        const value = picker.values[index];
+        if (index < 0 || index >= picker.values.length)
+            return;
+        setChoicePicker(null);
+        if (picker.kind === 'permission-mode') {
+            applyPermissionMode(value);
+            return;
+        }
+        applyReasoningEffort(value);
+    }, [applyPermissionMode, applyReasoningEffort, setChoicePicker]);
     const sendCopyRequest = useCallback((index) => {
         const picker = copyPickerRef.current;
         const target = picker?.targets[index];
@@ -762,15 +836,14 @@ export function App({ ctx: initialCtx }) {
      * nobody can see. Everything this path says goes into `pickerNotice`, which
      * the picker renders.
      *
-     * It uses the browser route only. There is no paste input on this screen,
-     * and rather than invent one — a second text field beside the credential
-     * one, on the screen an operator reaches when they are already stuck — the
-     * no-browser case is handed to `namzu login`, which reads the pasted
-     * address from standard input and exists for exactly that machine.
+     * The registered browser callback shows a code rather than returning to a
+     * local listener. The picker therefore owns the matching paste field; sending a
+     * first-run operator to another terminal would make the sign-in technically
+     * started here but impossible to finish on the screen that started it.
      */
     const startLoginFromPicker = useCallback(async (provider, signal) => {
         if (signal.aborted)
-            return;
+            return 'failed';
         cancelPendingLogin();
         if (provider === 'codex') {
             let start;
@@ -781,11 +854,11 @@ export function App({ ctx: initialCtx }) {
                 if (!signal.aborted) {
                     setPickerNotice(`Could not start Codex sign-in: ${error instanceof Error ? error.message : String(error)}`);
                 }
-                return;
+                return 'failed';
             }
             if (signal.aborted) {
                 start.cancel();
-                return;
+                return 'failed';
             }
             codexLoginRef.current = start;
             setPickerNotice(describeCodexDeviceLoginStart({
@@ -795,7 +868,7 @@ export function App({ ctx: initialCtx }) {
             }));
             const outcome = await start.waitForCompletion();
             if (codexLoginRef.current !== start || signal.aborted)
-                return;
+                return 'failed';
             codexLoginRef.current = null;
             start.cancel();
             setPickerNotice(describeLoginOutcome(outcome));
@@ -803,7 +876,7 @@ export function App({ ctx: initialCtx }) {
                 setPickerInitialView('providers');
                 await runProbeRef.current?.(signal);
             }
-            return;
+            return 'finished';
         }
         let start;
         try {
@@ -811,13 +884,13 @@ export function App({ ctx: initialCtx }) {
         }
         catch (err) {
             if (signal.aborted)
-                return;
+                return 'failed';
             setPickerNotice(`Could not start a sign-in: ${err instanceof Error ? err.message : String(err)}`);
-            return;
+            return 'failed';
         }
         if (signal.aborted) {
             start.cancel();
-            return;
+            return 'failed';
         }
         loginRef.current = start;
         const cancelForPicker = () => {
@@ -832,36 +905,39 @@ export function App({ ctx: initialCtx }) {
         signal.addEventListener('abort', cancelForPicker, { once: true });
         if (signal.aborted) {
             cancelForPicker();
-            return;
+            return 'failed';
         }
         setPickerNotice(describeLoginStart({
             url: start.url,
-            loopback: start.loopback,
             browserOpened: openInBrowser(start.url),
-            // Named for THIS screen. Telling someone at the picker to type a
-            // slash command is what made the feature unreachable; telling them
-            // to run a command in another terminal is something they can do
-            // from where they are sitting.
-            completionHint: 'run "namzu login" in a terminal and paste it there',
+            completionHint: 'paste it below and press enter',
         }));
-        const waiting = start.waitForCallback();
-        if (!waiting)
-            return;
-        const outcome = await waiting;
-        if (loginRef.current !== start || signal.aborted)
-            return;
+        return 'awaiting-input';
+    }, [cancelPendingLogin]);
+    const finishLoginFromPicker = useCallback(async (pasted, signal) => {
+        const pending = loginRef.current;
+        if (!pending) {
+            setPickerNotice('There is no Claude sign-in waiting for this code. Start it again.');
+            return 'finished';
+        }
+        if (!parsePastedInput(pasted).code) {
+            setPickerNotice('That does not contain an authorization code. Paste the whole finished address, or the code Claude showed.');
+            return 'retry';
+        }
+        const outcome = await pending.completeWithPastedCode(pasted);
+        if (loginRef.current !== pending || signal.aborted)
+            return 'finished';
         loginRef.current = null;
-        cleanup();
+        loginAbortCleanupRef.current?.();
         loginAbortCleanupRef.current = null;
-        start.cancel();
-        if (!outcome.ok && outcome.reason.includes('cancelled'))
-            return;
+        pending.cancel();
         setPickerNotice(describeLoginOutcome(outcome));
         if (outcome.ok) {
             setPickerInitialView('providers');
             await runProbeRef.current?.(signal);
         }
-    }, [cancelPendingLogin]);
+        return 'finished';
+    }, []);
     const runProbe = useCallback(async (signal) => {
         try {
             if (signal?.aborted)
@@ -2068,6 +2144,10 @@ export function App({ ctx: initialCtx }) {
                     setPhase('picker');
                     return;
                 case 'permission-mode': {
+                    applyPermissionMode(slash.mode);
+                    return;
+                }
+                case 'permission-mode-picker': {
                     if (!session?.hasProvider) {
                         pushMessage('system', 'No active session — pick a provider before changing permissions.');
                         return;
@@ -2077,24 +2157,34 @@ export function App({ ctx: initialCtx }) {
                         hasUnsettledTurn() ||
                         queuedRef.current.length > 0 ||
                         permissionResolveRef.current !== null ||
-                        compactingRef.current) {
-                        pushMessage('system', 'Permission mode was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
-                        return;
-                    }
-                    if (!session.resetApprovalLatch) {
-                        pushMessage('system', 'Permission mode was not changed: this embedded session cannot revoke an earlier "approve all" choice. Reconnect it before changing modes.');
+                        compactingRef.current ||
+                        !session.resetApprovalLatch) {
+                        pushMessage('system', 'Permission choices are unavailable until the active turn, prompt, compaction, queued work, or embedded-session approval latch can be safely settled.');
                         return;
                     }
-                    session.resetApprovalLatch();
-                    permissionModeRef.current = slash.mode;
-                    permissionModeSourceRef.current = 'session';
-                    setPermissionModeState(slash.mode);
-                    pushMessage('system', `Permission mode changed to ${slash.mode}. Any earlier "approve all" choice was revoked. Declarative deny rules and the built-in safety gate still take precedence.`);
+                    const values = ['prompt', 'auto', 'strict'];
+                    setSelectedChoice(Math.max(0, values.indexOf(permissionModeRef.current)));
+                    setChoicePicker({
+                        kind: 'permission-mode',
+                        title: 'Select Permission Mode',
+                        notice: permissionPickerNotice(session),
+                        values,
+                        options: values.map((mode) => ({
+                            label: mode,
+                            description: permissionModeDescription(mode),
+                            current: mode === permissionModeRef.current,
+                        })),
+                    });
                     return;
                 }
                 case 'reasoning-effort': {
-                    if (!session?.hasProvider) {
-                        pushMessage('system', 'No active session — pick a provider before changing reasoning effort.');
+                    applyReasoningEffort(slash.effort ?? undefined);
+                    return;
+                }
+                case 'reasoning-effort-picker': {
+                    const levels = session?.reasoningEffortLevels;
+                    if (!session?.hasProvider || levels === undefined) {
+                        pushMessage('system', 'No exact reasoning-effort menu is available for the current session.');
                         return;
                     }
                     if (state !== 'idle' ||
@@ -2103,20 +2193,22 @@ export function App({ ctx: initialCtx }) {
                         queuedRef.current.length > 0 ||
                         permissionResolveRef.current !== null ||
                         compactingRef.current) {
-                        pushMessage('system', 'Reasoning effort was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
-                        return;
-                    }
-                    if (slash.effort === null) {
-                        setReasoningEffort(undefined);
-                        pushMessage('system', 'Reasoning effort reset to the provider default for future main-query turns.');
+                        pushMessage('system', 'Reasoning-effort choices are unavailable until the active turn, prompt, compaction, and queued work settle.');
                         return;
                     }
-                    if (!session.reasoningEffortLevels?.includes(slash.effort)) {
-                        pushMessage('system', `Reasoning effort was not changed: ${slash.effort} is not offered by every usable provider-chain member for this model.`);
-                        return;
-                    }
-                    setReasoningEffort(slash.effort);
-                    pushMessage('system', `Reasoning effort changed to ${slash.effort} for future main-query turns in this session.`);
+                    const values = [undefined, ...levels];
+                    const current = reasoningEffortRef.current;
+                    setSelectedChoice(Math.max(0, values.findIndex((value) => value === current)));
+                    setChoicePicker({
+                        kind: 'reasoning-effort',
+                        title: `Select Reasoning Level for ${session.modelSummary ?? 'current model'}`,
+                        values,
+                        options: values.map((effort) => ({
+                            label: effort ?? 'default',
+                            description: reasoningEffortDescription(effort),
+                            current: effort === current,
+                        })),
+                    });
                     return;
                 }
                 case 'login':
@@ -2587,6 +2679,8 @@ export function App({ ctx: initialCtx }) {
     }, [
         activeSkills,
         advanceQueueContinuation,
+        applyPermissionMode,
+        applyReasoningEffort,
         ctx.cwd,
         doResume,
         enqueueQueued,
@@ -2596,12 +2690,45 @@ export function App({ ctx: initialCtx }) {
         pushMessage,
         rawOutput,
         resetTranscript,
+        setChoicePicker,
         setCopyPicker,
         setReasoningEffort,
         slashCtx,
         startFreshConversation,
         state,
     ]);
+    // Keep the footer on the same durable goal record the driver mutates. A ref
+    // alone cannot repaint React, so every goal mutation bumps goalDriveVersion;
+    // generation/session checks stop a late disk read labelling a resumed chat.
+    useEffect(() => {
+        void goalDriveVersion;
+        const sessions = sessionsRef.current;
+        const scope = scopeRef.current;
+        if (!sessions?.goals || !scope) {
+            setGoalStatus(null);
+            return;
+        }
+        const generation = conversationGenRef.current;
+        const sessionId = scope.sessionId;
+        let disposed = false;
+        void sessions.goals
+            .getGoal(sessionId, sessions.tenantId)
+            .then((goal) => {
+            if (disposed ||
+                conversationGenRef.current !== generation ||
+                scopeRef.current?.sessionId !== sessionId) {
+                return;
+            }
+            setGoalStatus(goal);
+        })
+            .catch(() => {
+            if (!disposed && conversationGenRef.current === generation)
+                setGoalStatus(null);
+        });
+        return () => {
+            disposed = true;
+        };
+    }, [goalDriveVersion, phase, session]);
     // Admit automatic work only at a whole-App durable boundary. This effect
     // reserves; it never starts a turn itself. The one queue pump below remains
     // the sole starter, which is what keeps a human prompt that arrives during
@@ -2622,6 +2749,7 @@ export function App({ ctx: initialCtx }) {
             conversationMutationRef.current ||
             exportingRef.current ||
             compactingRef.current ||
+            choicePickerRef.current ||
             copyPickerRef.current ||
             goalCommandInFlightRef.current) {
             return;
@@ -2647,6 +2775,7 @@ export function App({ ctx: initialCtx }) {
                     conversationMutationRef.current ||
                     exportingRef.current ||
                     compactingRef.current ||
+                    choicePickerRef.current ||
                     copyPickerRef.current ||
                     goalCommandInFlightRef.current ||
                     queuedRef.current.length > 0 ||
@@ -2705,6 +2834,7 @@ export function App({ ctx: initialCtx }) {
         conversationMutation,
         session,
         state,
+        choicePicker,
         copyPicker,
         wakeGoalDriver,
     ]);
@@ -2720,6 +2850,7 @@ export function App({ ctx: initialCtx }) {
             conversationMutationRef.current ||
             exportingRef.current ||
             compactingRef.current ||
+            choicePickerRef.current ||
             copyPickerRef.current ||
             goalCommandInFlightRef.current)
             return;
@@ -2735,6 +2866,7 @@ export function App({ ctx: initialCtx }) {
         phase,
         queued,
         queuePause,
+        choicePicker,
         copyPicker,
         dequeueQueued,
         hasUnsettledTurn,
@@ -2978,6 +3110,34 @@ export function App({ ctx: initialCtx }) {
                 resolvePermission({ kind: 'approve-all' });
             return;
         }
+        // Finite slash-command choices own the keyboard below a live permission
+        // request and above the ordinary composer. Their values are a captured
+        // menu, so a provider/session change cannot silently reinterpret Enter.
+        if (choicePickerRef.current) {
+            const options = choicePickerRef.current.options;
+            if (key.escape || (key.ctrl && input === 'c')) {
+                setChoicePicker(null);
+                return;
+            }
+            if (key.upArrow) {
+                setSelectedChoice((index) => Math.max(0, index - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setSelectedChoice((index) => Math.min(options.length - 1, index + 1));
+                return;
+            }
+            if (key.return) {
+                applyChoiceSelection(selectedChoice);
+                return;
+            }
+            if (/^[1-9]$/.test(input)) {
+                const index = Number(input) - 1;
+                if (options[index])
+                    applyChoiceSelection(index);
+            }
+            return;
+        }
         // `/copy` holds a source snapshot, not a lifecycle phase. Permission
         // stays above it in this handler so an approval request that arrives
         // while the picker is open cannot have its keys stolen by the chooser.
@@ -3082,32 +3242,46 @@ export function App({ ctx: initialCtx }) {
     // Background is left natural — we inherit the terminal's own background
     // and only theme the foreground. Forcing
     // a filled bg left mismatched patches around bordered areas, so we don't.
-    return (_jsxs(Box, { flexDirection: "column", children: [phase !== 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, permissionMode: permissionMode, cwd: ctx.cwd })) : null, _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'resume' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume })) : phase === 'edit' ? (_jsx(EditPromptPicker, { prompts: editList, selected: selectedEdit })) : phase === 'picker' ? (_jsx(Picker, { detected: pickerDetected ?? detected, currentProvider: currentProvider, selectionKind: pickerSelectionKind, currentModel: session?.modelSummary ?? null, initialView: pickerInitialView, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel, onCredential: handleTypedCredential, onLogin: (provider, signal) => void startLoginFromPicker(provider, signal), keyEntryFor: keyEntryFor, notice: pickerNotice })) : (_jsxs(_Fragment, { children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: window.settled, resetKey: resetKey, raw: rawOutput, header: phase === 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, permissionMode: permissionMode, cwd: ctx.cwd })) : undefined }) }), spacerRows > 0 ? _jsx(Box, { height: spacerRows }) : null, _jsx(LiveActivity, { activeTools: activeTools, thinking: state === 'thinking' && !messages.some((m) => m.pending) }), permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls })) : copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { focus: state === 'idle' &&
-                                    phase === 'ready' &&
-                                    conversationMutation === null &&
-                                    copyPicker === null, hidden: permission !== null || copyPicker !== null, children: [queued.length > 0 && permission === null && copyPicker === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: [queuePause ? '⏸' : '⏎', " ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014", ' ', queuePause
-                                                    ? `paused after a ${queuePause.outcome} turn; send a message or change model to continue`
-                                                    : 'sending when ready'] }) })) : null, _jsx(Composer, { disabled: phase !== 'ready' ||
-                                            state === 'awaiting-permission' ||
-                                            compacting ||
-                                            conversationMutation !== null, hidden: permission !== null || copyPicker !== null, 
-                                        // A turn is running, so Esc is the interrupt and not
-                                        // the composer's clear.
-                                        escapeInterrupts: !compacting && (state === 'thinking' || state === 'tool'), onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), userCommands: userCommands, history: history })] })] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary
-                                ? `${session.modelSummary}${reasoningEffort ? ` · effort ${reasoningEffort}` : ''}`
-                                : null, state: state, hint: conversationMutation === 'fork'
-                                ? 'forking conversation — input is paused'
-                                : conversationMutation === 'edit'
-                                    ? 'branching before prompt — input is paused'
-                                    : conversationMutation === 'new'
-                                        ? 'starting a fresh conversation — input is paused'
-                                        : compacting
-                                            ? 'compacting conversation — input is paused'
-                                            : permission
-                                                ? hintForPhase(phase, state, session?.hasProvider === true)
+    return (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'resume' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume })) : phase === 'edit' ? (_jsx(EditPromptPicker, { prompts: editList, selected: selectedEdit })) : phase === 'picker' ? (_jsx(Picker, { detected: pickerDetected ?? detected, currentProvider: currentProvider, selectionKind: pickerSelectionKind, currentModel: session?.modelSummary ?? null, initialView: pickerInitialView, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel, onCredential: handleTypedCredential, onLogin: startLoginFromPicker, onLoginComplete: finishLoginFromPicker, keyEntryFor: keyEntryFor, notice: pickerNotice })) : (_jsxs(_Fragment, { children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: window.settled, resetKey: resetKey, raw: rawOutput, header: phase === 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, permissionMode: permissionMode, cwd: ctx.cwd })) : undefined }) }), spacerRows > 0 ? _jsx(Box, { height: spacerRows }) : null, _jsx(LiveActivity, { activeTools: activeTools, thinking: state === 'thinking' && !messages.some((m) => m.pending) }), permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls })) : choicePicker ? (_jsx(ChoicePicker, { title: choicePicker.title, notice: choicePicker.notice, options: choicePicker.options, selected: selectedChoice })) : copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { focus: state === 'idle' &&
+                                phase === 'ready' &&
+                                conversationMutation === null &&
+                                choicePicker === null &&
+                                copyPicker === null, hidden: permission !== null || choicePicker !== null || copyPicker !== null, children: [queued.length > 0 &&
+                                    permission === null &&
+                                    choicePicker === null &&
+                                    copyPicker === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: [queuePause ? '⏸' : '⏎', " ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014", ' ', queuePause
+                                                ? `paused after a ${queuePause.outcome} turn; send a message or change model to continue`
+                                                : 'sending when ready'] }) })) : null, _jsx(Composer, { disabled: phase !== 'ready' ||
+                                        state === 'awaiting-permission' ||
+                                        compacting ||
+                                        conversationMutation !== null, hidden: permission !== null || choicePicker !== null || copyPicker !== null, 
+                                    // A turn is running, so Esc is the interrupt and not
+                                    // the composer's clear.
+                                    escapeInterrupts: !compacting && (state === 'thinking' || state === 'tool'), onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), userCommands: userCommands, history: history })] })] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort ?? 'default', goal: phase === 'ready' &&
+                            state === 'idle' &&
+                            conversationMutation === null &&
+                            !compacting &&
+                            permission === null &&
+                            choicePicker === null &&
+                            copyPicker === null
+                            ? goalStatusLabel(goalStatus)
+                            : null, state: state, hint: conversationMutation === 'fork'
+                            ? 'forking conversation — input is paused'
+                            : conversationMutation === 'edit'
+                                ? 'branching before prompt — input is paused'
+                                : conversationMutation === 'new'
+                                    ? 'starting a fresh conversation — input is paused'
+                                    : compacting
+                                        ? 'compacting conversation — input is paused'
+                                        : permission
+                                            ? hintForPhase(phase, state, session?.hasProvider === true)
+                                            : choicePicker
+                                                ? 'choice open — ↑↓ / 1–9 select · enter apply · esc cancel'
                                                 : copyPicker
                                                     ? 'copy target open — ↑↓ / 1–9 select · esc cancel'
-                                                    : hintForPhase(phase, state, session?.hasProvider === true), usage: usage, context: context }) })] })] }));
+                                                    : goalStatus && phase === 'ready' && state === 'idle'
+                                                        ? undefined
+                                                        : hintForPhase(phase, state, session?.hasProvider === true), usage: usage, context: context }) })] }) }));
 }
 function Banner({ version, session, permissionMode, cwd, }) {
     const cols = process.stdout.columns ?? 80;
@@ -3163,7 +3337,66 @@ canReturn = false) {
         return 'y approve · n / esc reject · a approve all';
     if (state !== 'idle')
         return 'agent is working — esc to interrupt';
-    return '/help · Esc×2 edit previous · @file / Ctrl+V attach · Ctrl+C ×2 to exit';
+    // The composer already points to /help. Keeping the complete key legend in
+    // every idle frame made ordinary conversation read like a permanent setup
+    // screen; only state-specific actions belong in the footer.
+    return '';
+}
+function goalStatusLabel(goal) {
+    if (!goal)
+        return null;
+    switch (goal.phase) {
+        case 'active':
+            return 'Pursuing goal';
+        case 'paused':
+            return 'Goal paused (/goal resume)';
+        case 'blocked':
+            return 'Goal stalled (/goal resume)';
+        case 'complete':
+            return 'Goal achieved';
+    }
+}
+function permissionModeDescription(mode) {
+    switch (mode) {
+        case 'prompt':
+            return 'Ask before an undecided tool call runs';
+        case 'auto':
+            return 'Approve undecided calls unless a rule or safety gate refuses';
+        case 'strict':
+            return 'Refuse undecided calls; explicit allow rules still work';
+    }
+}
+function permissionPickerNotice(session) {
+    const notices = [];
+    if (session.approvalLatched()) {
+        notices.push('Approve all is active; applying any mode revokes it.');
+    }
+    const exempt = session.promptExemptTools();
+    if (exempt.length > 0)
+        notices.push(`Never prompted: ${exempt.join(', ')}.`);
+    return notices.length > 0 ? notices.join(' ') : undefined;
+}
+function reasoningEffortDescription(effort) {
+    switch (effort) {
+        case undefined:
+            return 'Use the provider and model default';
+        case 'none':
+            return 'No deliberate reasoning where the model supports it';
+        case 'minimal':
+            return 'Fastest responses with minimal reasoning';
+        case 'low':
+            return 'Fast responses with light reasoning';
+        case 'medium':
+            return 'Balance speed and reasoning depth';
+        case 'high':
+            return 'Deeper reasoning for complex problems';
+        case 'xhigh':
+            return 'Very deep reasoning for hard problems';
+        case 'max':
+            return 'Maximum reasoning depth offered by this model';
+        case 'ultra':
+            return 'Highest host-level reasoning setting when supported';
+    }
 }
 /**
  * The summary text, as collapsible detail under the compaction row.