@namzu/cli 18.0.0 → 19.0.0

package/dist/tui/App.js

@@ -12,7 +12,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  *      automatic reuse is not mistaken for a durable operator preference.
  */
 import { join, relative } from 'node:path';
-import { DefaultPathBuilder, DiskMessageFeedbackStore, GoalRoundLimitError, HostCommandRegistry, RunCancelled, SessionGoalActivation, StaleGoalError, asSessionId, createAssistantMessage, createUserMessage, generateRunId, generateSessionId, isCompactionMessage, kernelHostCommands, } from '@namzu/sdk';
+import { DEFAULT_MAX_GOAL_ROUNDS, DefaultPathBuilder, DiskMessageFeedbackStore, GoalRoundLimitError, HostCommandRegistry, RunCancelled, SessionGoalActivation, StaleGoalError, asSessionId, createAssistantMessage, createUserMessage, generateRunId, generateSessionId, isCompactionMessage, kernelHostCommands, } from '@namzu/sdk';
 import { Box, Text, useApp, useInput, useStdout, useWindowSize } from 'ink';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { pinTrustedProjectPath, resolveTrustedProjectContext, } from '../config/trusted-project-context.js';
@@ -26,11 +26,14 @@ import { conversationMarkdown, writeConversationExport, } from '../integrations/
 import { isTrusted, trustDir } from '../integrations/trust/store.js';
 import { checkUpdates } from '../integrations/updates.js';
 import { appendMemory, composeMemoryPrompt, readMemory } from '../memory/store.js';
+import { permissionModeDescription } from '../permissions/mode.js';
 import { composeSkillsPrompt, discoverSkills, loadSkillBody } from '../skills/store.js';
 import { discoverUserCommands } from '../user-commands/store.js';
 import { AgentCockpit, AgentTaskPanel, AgentTranscript, activeSubagentCohorts, agentCockpitIsWide, agentPhasePageSize, agentPhases, agentPickerPageSize, agentTranscriptPageSize, maxAgentTranscriptTailOffset, } from './AgentExplorer.js';
+import { BrandHeader } from './BrandHeader.js';
 import { ChoicePicker } from './ChoicePicker.js';
 import { Composer, suggestionWindowSize, } from './Composer.js';
+import { ComposerFrame } from './ComposerFrame.js';
 import { CopyPicker } from './CopyPicker.js';
 import { EditPromptPicker } from './EditPromptPicker.js';
 import { LiveActivity, formatElapsed } from './LiveActivity.js';
@@ -38,10 +41,12 @@ import { PermissionOverlay } from './PermissionOverlay.js';
 import { Picker } from './Picker.js';
 import { ResumePicker } from './ResumePicker.js';
 import { StatusBar } from './StatusBar.js';
+import { TaskList } from './TaskList.js';
 import { TextPrompt } from './TextPrompt.js';
 import { Transcript, willCollapse } from './Transcript.js';
 import { TrustPrompt } from './TrustPrompt.js';
 import { createAgentSession, probeAgentSession, } from './agent.js';
+import { choicePickerWindowSize, filterChoiceOptions, moveChoiceSelection, } from './choice-selection.js';
 import { keepRecentRows } from './compact-transcript.js';
 import { approvalIsDeliberate } from './consent-timing.js';
 import { planTurnPublication } from './conversation-history.js';
@@ -50,19 +55,48 @@ import { editablePrompts } from './edit-prompts.js';
 import { editDraftInExternalEditor } from './external-editor.js';
 import { liveWindow } from './live-window.js';
 import { describeCodexDeviceLoginStart, describeLoginOutcome, describeLoginStart, describeLogout, describeProviderLogout, } from './login-prompt.js';
-import { NAMZU_MARK, NAMZU_MARK_COLOR, NAMZU_WORDMARK, NAMZU_WORDMARK_GRADIENT, NAMZU_WORDMARK_MIN_WIDTH, } from './logo.js';
+import { selectPrimaryProvider } from './provider-selection.js';
+import { eraseLastChoiceGrapheme } from './terminal-choice-text.js';
+import { renderCheckpoints, renderRestore } from '../checkpoints/store.js';
 import { expandFileMentions, listMentionableFiles } from './mentions.js';
 import { openInBrowser } from './open-browser.js';
-import { PERMISSION_REVIEW_PAGE_ROWS, buildPermissionReview, buildPermissionSummary, permissionReviewRefusal, permissionReviewRows, } from './permission-review.js';
+import { buildPermissionReview, buildPermissionSummary, permissionReviewPageRows, permissionReviewRefusal, permissionReviewRows, } from './permission-review.js';
 import { describeRunInterruption } from './run-interruption.js';
 import { moveSelection } from './selection-window.js';
+import { describeShellEscape, describeShellEscapeForModel, runShellEscape, shellEscapeCommand, } from './shell-escape.js';
 import { baseBranchReviewPrompt, commitReviewPrompt, hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
-import { splitCompleteBlocks } from './stream-blocks.js';
+import { splitCompleteBlocks, splitSafeCut } from './stream-blocks.js';
 import { terminalSupportsHyperlinks } from './terminal-hyperlinks.js';
 import { theme } from './theme.js';
 import { useSelectionIndex } from './use-selection-index.js';
 import { renderWorkspaceDiff, workspaceDiff } from './workspace-diff.js';
 import { listReviewBranches, listReviewCommits, reviewMergeBase, } from './workspace-review.js';
+/** How long `/exit` waits for the session to close before leaving anyway. */
+const SESSION_CLOSE_ON_EXIT_MS = 5_000;
+/** The value a question row carries: an option id, or the free-text escape. */
+const FREE_TEXT_ANSWER = '__free_text__';
+/**
+ * The streaming assistant bubble, carried across events within one turn.
+ *
+ * `text` is everything the model has said and is what gets persisted;
+ * `pending` is the part not yet on screen, held until it forms a whole block.
+ * The two are separate because they answer different questions — what was
+ * said, and what has been shown — and conflating them is how a reply gets
+ * saved with a paragraph the operator never saw, or shown twice.
+ */
+/**
+ * How long held reply text may wait before a sentence of it is shown.
+ *
+ * Blocks are released as they complete (`splitCompleteBlocks`), which keeps a
+ * fast reply landing a paragraph at a time. A slow one — a long paragraph
+ * arriving over twenty seconds — completes no block until its last character
+ * and was invisible for its whole length. Past this interval the pending
+ * text is released to its last safe cut instead (`splitSafeCut`): a sentence
+ * or a line, never a half-word, never inside a fence. Long enough that a
+ * fast stream never reaches it; short enough that a slow one reads as
+ * writing rather than as silence.
+ */
+const STREAM_RELEASE_MS = 250;
 /** Last non-empty assistant text in a durable conversation, newest first. */
 function latestAssistantOutput(messages) {
     for (let i = messages.length - 1; i >= 0; i -= 1) {
@@ -280,7 +314,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const [pickerDetected, setPickerDetected] = useState(null);
     /** Whether Enter accepts the provider directly or continues to model choice. */
     const [pickerSelectionKind, setPickerSelectionKind] = useState('provider-and-model');
-    /** The chain read from disk, held while the picker repairs its credential. */
+    /** Active preferences, or the saved chain awaiting its missing credential. */
     const savedPrefsRef = useRef(null);
     /**
      * Why the picker is open, drawn ON the picker.
@@ -292,6 +326,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      */
     const [pickerNotice, setPickerNotice] = useState(null);
     const [permission, setPermission] = useState(null);
+    /**
+     * The question currently on screen and the promise the tool is waiting
+     * on. Resolved exactly once: by a chosen row, by free text, by Esc (skip)
+     * or by Ctrl+C (abort). A second resolution is a no-op, not a second
+     * answer.
+     */
+    const questionRef = useRef(null);
+    const resolveQuestion = useCallback((answer) => {
+        const pending = questionRef.current;
+        if (!pending?.resolve)
+            return;
+        const resolve = pending.resolve;
+        pending.resolve = null;
+        questionRef.current = null;
+        resolve(answer);
+    }, []);
     const [permissionReviewOffset, setPermissionReviewOffsetState] = useState(0);
     const permissionReviewOffsetRef = useRef(0);
     const [permissionDetailsOpen, setPermissionDetailsOpenState] = useState(false);
@@ -304,6 +354,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         permissionReviewOffsetRef.current = next;
         setPermissionReviewOffsetState(next);
     }, []);
+    // Which of the three answers the cursor is on. Opens on "Yes", as the
+    // prompt an operator knows from elsewhere does; Enter confirms it only
+    // after the same settle window `y` and `a` wait out.
+    const [permissionChoice, setPermissionChoiceState] = useState(0);
+    const permissionChoiceRef = useRef(0);
+    const setPermissionChoice = useCallback((next) => {
+        permissionChoiceRef.current = next;
+        setPermissionChoiceState(next);
+    }, []);
     // The launch bypass is an INITIAL selection, not permanent authority. A
     // typed /permissions command can narrow it back to prompt/strict without
     // rebuilding the provider, tools, plugins, or sandbox.
@@ -325,10 +384,74 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     /** Git-admitted file paths cached once per successful session hydration. */
     const [mentionCandidates, setMentionCandidates] = useState([]);
     const mentionLoadOwnerRef = useRef(null);
+    // What compaction has done this session, summed over passes; `/context`
+    // prints it. Reset with the session, never by a pass that declined.
+    const [compactionTally, setCompactionTally] = useState({
+        passes: 0,
+        clearedResults: 0,
+        stubbedNarrations: 0,
+        summaries: 0,
+        reclaimedTokens: 0,
+    });
+    // Jobs that ended while no turn was running. The kernel's notice needs a
+    // tool result to ride on, so between turns the exit is held here and
+    // handed to the next send as part of the system text; the transcript
+    // row is written at once.
+    const idleJobNoticesRef = useRef([]);
+    const drainIdleJobNotices = () => {
+        if (idleJobNoticesRef.current.length === 0)
+            return undefined;
+        const lines = idleJobNoticesRef.current;
+        idleJobNoticesRef.current = [];
+        return `Background jobs that ended since your last turn:\n${lines.map((l) => `- ${l}`).join('\n')}`;
+    };
+    // Commands the operator ran with `!` since the last turn. The model did
+    // not see them happen; it reads them here on its next turn.
+    const operatorShellRef = useRef([]);
+    const drainOperatorShell = () => {
+        if (operatorShellRef.current.length === 0)
+            return undefined;
+        const blocks = operatorShellRef.current;
+        operatorShellRef.current = [];
+        return `What the operator did outside you since your last turn — commands they ran in their own shell, files they put back — with the output:\n\n${blocks.join('\n\n')}`;
+    };
+    useEffect(() => {
+        if (!session?.onJobExit)
+            return;
+        return session.onJobExit((job) => {
+            if (abortRef.current !== null)
+                return;
+            const text = describeJobExit({
+                jobId: job.id,
+                command: job.command,
+                status: job.status === 'killed' ? 'killed' : 'exited',
+                ...(job.exitCode !== undefined ? { exitCode: job.exitCode } : {}),
+                ...(job.signal ? { signal: job.signal } : {}),
+            });
+            idleJobNoticesRef.current.push(text);
+            pushMessage('system', text, false, '⚙');
+        });
+    }, [session]);
     const [usage, setUsage] = useState(null);
+    /**
+     * The model's current reasoning, last line only, for the live region.
+     * Never appended to a message: the kernel keeps reasoning out of its
+     * own transcript, and this exists so a long think reads as work rather
+     * than as silence. Cleared by the first text or tool call that follows.
+     */
+    const [thinking, setThinking] = useState(null);
     // Tools currently executing — rendered live (spinner + elapsed) below the
     // transcript, then committed as static lines on completion.
     const [activeTools, setActiveTools] = useState([]);
+    /**
+     * The model's plan for the current request, in creation order, updated in
+     * place on every status change. Cleared when the next request begins —
+     * a plan is scoped to the request it was made for, and one that outlived
+     * it would read as work still pending on a turn that already ended.
+     */
+    const [tasks, setTasks] = useState([]);
+    /** Ids already seen this request, so an opening row is written once. */
+    const knownTaskIdsRef = useRef(new Set());
     // Bumped to reset the <Static> transcript log (on /clear, /clear-screen and /resume).
     const [resetKey, setResetKey] = useState(0);
     /**
@@ -409,6 +532,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     /** Finite slash-command choice owned synchronously until apply or cancel. */
     const [choicePicker, setChoicePickerState] = useState(null);
     const choicePickerRef = useRef(null);
+    const [choiceQuery, setChoiceQuery] = useState('');
+    const choiceQueryRef = useRef('');
     /**
      * Exact chooser React has committed. The synchronous owner ref is needed to
      * block queue/goal work immediately, but it must not accept the Return key
@@ -419,6 +544,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const { selection: selectedChoice, selectionRef: selectedChoiceRef, setSelection: setSelectedChoice, } = useSelectionIndex(0);
     const setChoicePicker = useCallback((next) => {
         choicePickerRef.current = next;
+        choiceQueryRef.current = '';
+        setChoiceQuery('');
         if (next === null)
             choicePickerCommittedRef.current = null;
         setChoicePickerState(next);
@@ -592,14 +719,29 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      */
     const conversationMaterializedRef = useRef(false);
     const materializationRef = useRef(null);
+    /**
+     * The session owns processes — MCP servers, background jobs, the hooks'
+     * `session_end` — and Ink's exit does not close it. So the session is
+     * closed first, bounded, and the process leaves after: a server started
+     * with `run_in_background` used to outlive `/exit`, and a `session_end`
+     * hook never ran.
+     */
+    const closeAndExit = useCallback(() => {
+        const closing = session?.close() ?? Promise.resolve();
+        const bounded = Promise.race([
+            closing,
+            new Promise((resolve) => setTimeout(resolve, SESSION_CLOSE_ON_EXIT_MS).unref?.()),
+        ]);
+        void bounded.catch(() => undefined).finally(() => exit());
+    }, [exit, session]);
     const exitWithSummary = useCallback(() => {
         onExitSummary?.({
             ...(conversationMaterializedRef.current && scopeRef.current?.sessionId
                 ? { conversationId: scopeRef.current.sessionId }
                 : {}),
         });
-        exit();
-    }, [exit, onExitSummary]);
+        closeAndExit();
+    }, [closeAndExit, onExitSummary]);
     /** Durable active state is not permission to spend turns after a restart. */
     const [goalActivation] = useState(() => new SessionGoalActivation());
     const goalDriveInFlightRef = useRef(false);
@@ -988,7 +1130,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 archived = true;
                 goalActivation.clear();
                 onExitSummary?.({});
-                exit();
+                closeAndExit();
             }
             catch (error) {
                 pushMessage('system', `Could not archive this conversation: ${error instanceof Error ? error.message : String(error)}`);
@@ -1027,6 +1169,20 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
         return { sessions, sessionId };
     }, [hasUnsettledTurn, pushMessage, state]);
+    /**
+     * Shift+Tab: `prompt` → `accept-edits` → `plan` → `prompt`. Three stops
+     * only — `auto` and `strict` are deliberate choices made by name in
+     * `/permissions`, not stops on a key an operator presses on reflex. From
+     * either of those the key returns to `prompt`, which is the direction a
+     * reflex should fall. The change goes through the same gate `/permissions`
+     * uses, so it is refused while a turn is active, and the refusal is
+     * explained on screen.
+     */
+    const cyclePermissionMode = useCallback(() => {
+        const current = permissionModeRef.current;
+        const next = current === 'prompt' ? 'accept-edits' : current === 'accept-edits' ? 'plan' : 'prompt';
+        applyPermissionMode(next);
+    }, [applyPermissionMode]);
     const runConversationExport = useCallback((destination) => {
         const source = stableExportSource();
         if (!source)
@@ -1083,6 +1239,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         const value = picker.values[index];
         if (index < 0 || index >= picker.values.length)
             return;
+        if (picker.options[index]?.disabledReason)
+            return;
         if (picker.kind === 'review-preset') {
             if (reviewChoiceInFlightRef.current)
                 return;
@@ -1113,6 +1271,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         setSelectedChoice(0);
                         setChoicePicker({
                             kind: 'review-branch',
+                            back: picker,
                             title: 'Select a base branch',
                             notice: `Current branch: ${listing.current}`,
                             values: listing.branches,
@@ -1137,6 +1296,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         setSelectedChoice(0);
                         setChoicePicker({
                             kind: 'review-commit',
+                            back: picker,
                             title: 'Select a commit to review',
                             values: commits,
                             options: commits.map((commit) => ({
@@ -1209,6 +1369,39 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             })();
             return;
         }
+        if (picker.kind === 'user-question') {
+            const pending = questionRef.current;
+            setChoicePicker(null);
+            if (!pending)
+                return;
+            if (value === FREE_TEXT_ANSWER) {
+                // The scope on a text prompt is what its other kinds check
+                // against a conversation switch; a question belongs to the turn
+                // that asked it, and the turn holds the promise.
+                const scope = scopeRef.current;
+                if (!scope) {
+                    resolveQuestion({ kind: 'skip' });
+                    return;
+                }
+                textPromptTokenRef.current += 1;
+                setTextPrompt({
+                    token: textPromptTokenRef.current,
+                    kind: 'user-question',
+                    title: pending.question.question,
+                    placeholder: 'Type your answer and press Enter · Esc skips',
+                    emptyNotice: 'An empty answer is a skip. Press Esc to skip.',
+                    initialValue: '',
+                    sessionId: scope.sessionId,
+                });
+                return;
+            }
+            // The tool's own result row carries the answer the model saw; this
+            // row is the operator's, so a reader of the transcript sees the
+            // question and the choice together where it happened.
+            pushMessage('system', `Answered "${pending.question.question}": ${labelOfOption(pending.question, value)}`, false, '?');
+            resolveQuestion({ kind: 'answer', selectedOptionIds: [value] });
+            return;
+        }
         if (picker.kind === 'review-commit') {
             advanceQueueContinuation();
             enqueueQueued({
@@ -1226,6 +1419,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 return;
             }
             commandPickerSubmitRef.current(`/${command.name}`);
+            const child = choicePickerRef.current;
+            if (child)
+                setChoicePicker({ ...child, back: picker });
             return;
         }
         if (picker.kind === 'archive-conversation') {
@@ -1348,12 +1544,35 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * if every exit releases it; this is the function every exit calls.
      */
     const flushStream = useCallback((st) => {
+        if (st.releaseTimer) {
+            clearTimeout(st.releaseTimer);
+            st.releaseTimer = undefined;
+        }
         if (!st.pending || st.pending.length === 0)
             return;
         const id = st.assistantId ?? pushMessage('assistant', '', true);
         st.assistantId = id;
         appendToMessage(id, st.pending);
         st.pending = '';
+        st.releasedAt = Date.now();
+    }, [appendToMessage, pushMessage]);
+    /**
+     * Release held text to its last safe cut — a sentence or a line — when it
+     * has waited longer than `STREAM_RELEASE_MS`. Called from the delta path
+     * with the clock, and from the timer the delta path arms so a stream that
+     * goes quiet mid-paragraph still shows what it has.
+     */
+    const releaseStalled = useCallback((st) => {
+        if (!st.pending || st.pending.length === 0)
+            return;
+        const { ready, rest } = splitSafeCut(st.pending);
+        if (ready.length === 0)
+            return;
+        const id = st.assistantId ?? pushMessage('assistant', '', true);
+        st.assistantId = id;
+        st.pending = rest;
+        appendToMessage(id, ready);
+        st.releasedAt = Date.now();
     }, [appendToMessage, pushMessage]);
     const finalizeMessage = useCallback((id, finalContent) => {
         setMessages((prev) => prev.map((m) => m.id === id ? { ...m, content: finalContent ?? m.content, pending: false } : m));
@@ -1384,6 +1603,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         else {
             // Provider/tool startup needs stable project/tenant/topic ids, not a
             // durable conversation. The cursor is replaced on first admitted use.
+            // The conversation's id, chosen now; the conversation is written
+            // under it at first durable use. Nothing that saw this id before
+            // that moment — a hook, a log line, the screen — is later wrong.
             sessionId = generateSessionId();
         }
         sessionsRef.current = sessions;
@@ -1411,11 +1633,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 return undefined;
             conversationMutationRef.current = 'materialize';
             try {
-                const sessionId = await startConversation(sessions);
+                const written = await startConversation(sessions, scope.sessionId);
                 if (scopeRef.current !== scope || conversationMaterializedRef.current) {
                     throw new Error('the active conversation changed while its first session was published');
                 }
-                scope.sessionId = sessionId;
+                // The store creates the conversation under the id chosen at open,
+                // so this is the same id; a store that cannot honour a chosen id
+                // is followed rather than contradicted.
+                if (written !== scope.sessionId)
+                    scope.sessionId = written;
                 conversationMaterializedRef.current = true;
                 return scope;
             }
@@ -1434,7 +1660,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 materializationRef.current = null;
         }
     }, [ensureSessions]);
-    const hydrateSession = useCallback(async (prefs, detectedNow, signal) => {
+    const hydrateSession = useCallback(async (prefs, detectedNow, signal, persistSelection = false) => {
         if (signal?.aborted)
             return;
         const scope = await ensureSessions();
@@ -1444,15 +1670,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         const s = await createAgentSession(prefs, detectedNow, {
             scope,
             cwd: activeCtx.cwd,
-            ...(sessionsRef.current?.backend === 'central'
-                ? { stateRoot: sessionsRef.current.root }
+            ...(activeCtx.additionalDirectories
+                ? { additionalDirectories: activeCtx.additionalDirectories }
                 : {}),
+            ...(sessionsRef.current ? { stateRoot: sessionsRef.current.root } : {}),
             enableComputerUse: true,
             rules: activeCtx.rules,
             ...(sessionsRef.current ? { sessionGoals: sessionsRef.current.goals } : {}),
             ...(activeCtx.mcpServers ? { mcpServers: activeCtx.mcpServers } : {}),
             ...(activeCtx.plugins ? { plugins: activeCtx.plugins } : {}),
+            ...(activeCtx.web ? { web: activeCtx.web } : {}),
+            ...(activeCtx.hooks ? { hooks: activeCtx.hooks } : {}),
+            ...(activeCtx.compaction ? { compaction: activeCtx.compaction } : {}),
             ...(activeCtx.sandbox ? { sandbox: activeCtx.sandbox } : {}),
+            // Somebody is at this terminal, so the model may ask them one
+            // question when a decision is genuinely theirs.
+            askUser: true,
         });
         if (signal?.aborted) {
             void s.close();
@@ -1469,6 +1702,24 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             }
             throw new Error(reason);
         }
+        let commands;
+        try {
+            commands = discoverUserCommands({ cwd: activeCtx.cwd, reserved: hostCommandNames() });
+            // Construction and validation precede the saved change. There is no
+            // await between this atomic write and publishing the usable session.
+            if (persistSelection)
+                writePreferences(prefs);
+        }
+        catch (error) {
+            try {
+                await s.close();
+            }
+            catch {
+                // Preserve the admission/save error and the still-active old session.
+            }
+            throw error;
+        }
+        savedPrefsRef.current = prefs;
         // A picker-owned provider/model change is one state transition. Clear the
         // old model's effort selection before publishing the replacement session
         // or releasing any paused queue. Failed and superseded candidates returned
@@ -1481,13 +1732,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         void previousSessionRef.current?.close();
         previousSessionRef.current = s;
         setSession(s);
-        setUserCommands(discoverUserCommands({
-            cwd: activeCtx.cwd,
-            // Builtins are reserved: a `help.md` must not take over `/help`.
-            // Passing the names here is what lets the loader tell its author
-            // the file is shadowed instead of leaving it silently unused.
-            reserved: hostCommandNames(),
-        }));
+        setUserCommands(commands);
         const mentionLoadOwner = {};
         mentionLoadOwnerRef.current = mentionLoadOwner;
         void listMentionableFiles(activeCtx.cwd, appLifetime.signal).then((files) => {
@@ -1849,6 +2094,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
     }, [activateTrustedProject, pushMessage, runProbe]);
     const finalized = messages.filter((m) => !m.pending);
+    // Activity and the plan share the terminal with the draft. Collapse the two
+    // lists together only when their full previews would crowd the input area.
+    const fullTaskFurniture = tasks.length === 0 ? 0 : Math.min(tasks.length, 8) + 3;
+    const fullToolFurniture = activeTools.length === 0 ? 0 : Math.min(activeTools.length, 3) * 2 + 2;
+    const compactWork = LIVE_FURNITURE_ROWS + fullTaskFurniture + fullToolFurniture >= terminal.rows;
+    const taskFurniture = compactWork && fullTaskFurniture > 0 ? 2 : fullTaskFurniture;
+    const toolFurniture = compactWork && fullToolFurniture > 0 ? 2 : fullToolFurniture;
     // How much of the transcript is still redrawable. The rest belongs to native
     // terminal scrollback; the live tail stays deliberately small so an activity
     // tick never repaints the whole conversation.
@@ -1860,7 +2112,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         messages: finalized,
         rows: terminal.rows,
         columns: terminal.columns,
-        furnitureRows: LIVE_FURNITURE_ROWS,
+        furnitureRows: LIVE_FURNITURE_ROWS + taskFurniture + toolFurniture,
         settled: settledRef.current,
         raw: rawOutput,
     });
@@ -1879,6 +2131,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const hostCommands = mergeHostCommands(kernelCommandDescriptors());
     const slashCtx = {
         cwd: ctx.cwd,
+        jobs: () => session?.jobs?.() ?? [],
+        hooks: () => session?.hooks,
+        directories: () => session?.directories?.list() ?? [],
+        compaction: session
+            ? {
+                strategy: ctx.compaction?.strategy ?? 'salience',
+                softTarget: 0.5,
+                triggerThreshold: 0.7,
+                ...compactionTally,
+            }
+            : null,
         builtins: hostCommands,
         lastAssistantMessageId: () => lastAssistantMessage.current?.messageId ?? null,
         // Called when `/tools` renders, not read here — the same shape, and the
@@ -1957,6 +2220,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         permissionOpenedAtRef.current = null;
         setPermissionReviewOffset(0);
         setPermissionDetailsOpen(false);
+        setPermissionChoice(0);
         setPermission(null);
         if (resolve) {
             // The provider resumes asynchronously after the decision. Leaving the
@@ -2083,6 +2347,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         wakeGoalDriver();
         conversationGenRef.current += 1;
         resetSubagentActivity();
+        session?.resetTaskStore?.();
         activeTurnTokenRef.current = null;
         resetTranscript();
         setMessages(restored);
@@ -2117,6 +2382,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         nextId,
         pushMessage,
         resetSubagentActivity,
+        session,
         resetTranscript,
         wakeGoalDriver,
     ]);
@@ -2157,6 +2423,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             wakeGoalDriver();
             conversationGenRef.current += 1;
             resetSubagentActivity();
+            session?.resetTaskStore?.();
             activeTurnTokenRef.current = null;
             modelHistoryRef.current = [];
             lastAssistantMessage.current = null;
@@ -2196,6 +2463,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         interruptTurn,
         pushMessage,
         resetSubagentActivity,
+        session,
         resetTranscript,
         wakeGoalDriver,
     ]);
@@ -2243,11 +2511,27 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         if (!prompt)
             return;
         setTextPrompt(null);
+        if (prompt.kind === 'user-question') {
+            const text = value.trim();
+            const pending = questionRef.current;
+            if (text.length === 0) {
+                resolveQuestion({ kind: 'skip' });
+                return;
+            }
+            if (pending) {
+                pushMessage('system', `Answered "${pending.question.question}": ${text}`, false, '?');
+            }
+            resolveQuestion({ kind: 'answer', selectedOptionIds: [], freeText: text });
+            return;
+        }
         const scope = scopeRef.current;
         if (!scope || scope.sessionId !== prompt.sessionId) {
-            pushMessage('system', prompt.kind === 'conversation-title'
-                ? 'The conversation changed while its name editor was open. Nothing was renamed; open /rename again.'
-                : 'The conversation changed while its export filename editor was open. Nothing was exported; open /export again.');
+            pushMessage('system', 'The conversation changed while this editor was open. Reopen the command in the current conversation.');
+            return;
+        }
+        if (prompt.kind === 'goal-create' || prompt.kind === 'goal-edit') {
+            if (value.trim())
+                commandPickerSubmitRef.current(`/goal ${prompt.kind === 'goal-create' ? 'set' : 'edit'} ${value.trim()}`);
             return;
         }
         if (prompt.kind === 'export-file') {
@@ -2275,8 +2559,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         queueMicrotask(() => {
             if (textPromptRef.current === prompt)
                 setTextPrompt(null);
+            // A cancelled free-text answer is a skipped question, not a hung tool.
+            if (prompt?.kind === 'user-question')
+                resolveQuestion({ kind: 'skip' });
         });
-    }, [setTextPrompt]);
+    }, [resolveQuestion, setTextPrompt]);
     /**
      * `/fork`: continue in a copy, leaving this conversation where it is.
      *
@@ -2321,6 +2608,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // is reloaded or reset. Only where the NEXT turn is written changes.
             scope.sessionId = forked.id;
             resetSubagentActivity();
+            session?.resetTaskStore?.();
             goalActivation.clear();
             wakeGoalDriver();
             pushMessage('system', `Forked into "${forked.title}" — ${forked.copied} message(s) copied. This screen continues in the copy; ${original} is unchanged and still in /resume.`);
@@ -2338,6 +2626,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         materializeConversation,
         pushMessage,
         resetSubagentActivity,
+        session,
         wakeGoalDriver,
     ]);
     /** Open the durable prompt picker after the composer's second empty Esc. */
@@ -2362,6 +2651,33 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         editCommittedRef.current = false;
         setPhase('edit');
     }, [hasUnsettledTurn, messages, pushMessage, state]);
+    /** `/restore`: list the file checkpoints, or put the tree back to before a turn. */
+    const doRestore = useCallback(async (turn) => {
+        const store = session?.checkpoints;
+        if (!store) {
+            pushMessage('system', 'This session keeps no file checkpoints.');
+            return;
+        }
+        if (turn === undefined) {
+            pushMessage('system', renderCheckpoints(store.list(), ctxRef.current.cwd));
+            return;
+        }
+        if (abortRef.current || state !== 'idle' || hasUnsettledTurn()) {
+            pushMessage('system', 'A turn is still running. Wait for it, or interrupt it, before restoring files.');
+            return;
+        }
+        try {
+            const report = await store.restore(turn);
+            const text = renderRestore(report, ctxRef.current.cwd);
+            pushMessage('system', text);
+            // The model's picture of those files is now wrong; it reads
+            // this before its next turn.
+            operatorShellRef.current.push(`/restore ${turn}\n${text}`);
+        }
+        catch (err) {
+            pushMessage('system', err instanceof Error ? err.message : String(err));
+        }
+    }, [hasUnsettledTurn, pushMessage, session, state]);
     /** Fork before the selected prompt, then reopen that prompt in the composer. */
     const confirmPromptEdit = useCallback(async (target) => {
         if (editCommittedRef.current || conversationMutationRef.current)
@@ -2396,6 +2712,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 .map((prompt) => prompt.displayText);
             conversationGenRef.current += 1;
             resetSubagentActivity();
+            session?.resetTaskStore?.();
             activeTurnTokenRef.current = null;
             goalActivation.clear();
             wakeGoalDriver();
@@ -2437,6 +2754,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         nextId,
         pushMessage,
         resetSubagentActivity,
+        session,
         resetTranscript,
         wakeGoalDriver,
     ]);
@@ -2461,6 +2779,39 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             sendTerminalNotification({ kind: 'approval-required' });
         });
     }, [sendTerminalNotification, setPermissionDetailsOpen, setPermissionReviewOffset]);
+    /**
+     * `ask_user_question`, on screen. The question becomes a finite chooser —
+     * the model's options, then "Something else…" when it allowed free text —
+     * and the tool's promise waits on the row the operator picks. One question
+     * at a time: the tool is not concurrency-safe, so a second cannot arrive
+     * while the first is up.
+     */
+    const askQuestion = useCallback((question) => new Promise((resolve) => {
+        questionRef.current = { question, resolve };
+        const values = [
+            ...question.options.map((option) => option.id),
+            ...(question.allowFreeText ? [FREE_TEXT_ANSWER] : []),
+        ];
+        setSelectedChoice(0);
+        setChoicePicker({
+            kind: 'user-question',
+            title: question.question,
+            notice: question.header
+                ? `${question.header} · Enter answers · Esc skips`
+                : 'Enter answers · Esc skips',
+            values,
+            options: [
+                ...question.options.map((option) => ({
+                    label: option.label,
+                    description: option.description ?? '',
+                })),
+                ...(question.allowFreeText
+                    ? [{ label: 'Something else…', description: 'Answer in your own words' }]
+                    : []),
+            ],
+        });
+        sendTerminalNotification({ kind: 'approval-required' });
+    }), [sendTerminalNotification, setChoicePicker, setSelectedChoice]);
     // Render one agent event onto the transcript. Shared by the local turn loop
     // and the daemon-attach poller, so both paths produce identical output.
     // `st` carries the streaming-assistant bubble id + accumulated text across
@@ -2481,6 +2832,20 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 st.assistantId = null;
             }
         };
+        if (event.kind !== 'usage' && 'budget' in event && event.budget) {
+            const budget = event.budget;
+            const own = st.lastUsage;
+            setUsage((previous) => ({
+                totalTokens: budget.ownTokens,
+                budget,
+                cost: {
+                    ...(own?.cost ?? { totalCost: 0, cacheDiscount: 0, unpricedTokens: 0 }),
+                    unpricedTokens: (own?.cost.unpricedTokens ?? 0) +
+                        Math.max(0, budget.ownTokens - (own?.totalTokens ?? 0)),
+                },
+                ...(own && previous?.context ? { context: previous.context } : {}),
+            }));
+        }
         switch (event.kind) {
             case 'delta': {
                 setState('thinking');
@@ -2491,6 +2856,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         sessionId: st.sessionId,
                     };
                 }
+                // The release clock starts with the first character, not with the
+                // turn: the wait before the first token is the model's, and
+                // counting it would release the opening sentence on arrival.
+                st.releasedAt ??= Date.now();
+                setThinking(null);
                 st.text += event.text;
                 // Held, not appended. Appending each delta is what produced text
                 // that types itself out — nothing animates it, but a few
@@ -2501,11 +2871,26 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 if (ready.length > 0) {
                     st.pending = rest;
                     appendToMessage(ensureAssistant(), ready);
+                    st.releasedAt = Date.now();
+                }
+                // A block is the preferred unit; a sentence is the fallback for
+                // a paragraph that is taking longer than an operator will wait
+                // for it. The timer covers the stream going quiet between two
+                // deltas, which the clock check alone cannot see.
+                if (st.releaseTimer)
+                    clearTimeout(st.releaseTimer);
+                if (Date.now() - (st.releasedAt ?? 0) >= STREAM_RELEASE_MS) {
+                    releaseStalled(st);
                 }
+                st.releaseTimer = setTimeout(() => {
+                    st.releaseTimer = undefined;
+                    releaseStalled(st);
+                }, STREAM_RELEASE_MS);
                 break;
             }
             case 'tool-start': {
                 closeAssistant();
+                setThinking(null);
                 setState('tool');
                 const tool = {
                     id: event.toolUseId,
@@ -2580,10 +2965,68 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 break;
             }
             case 'usage':
-                setUsage({ totalTokens: event.totalTokens, cost: event.cost });
+                st.lastUsage = event;
+                setUsage({
+                    totalTokens: event.totalTokens,
+                    ...(event.budget ? { budget: event.budget } : {}),
+                    cost: event.cost,
+                    ...(event.contextTokens !== undefined && event.contextWindowTokens !== undefined
+                        ? {
+                            context: {
+                                tokens: event.contextTokens,
+                                windowTokens: event.contextWindowTokens,
+                                measured: event.contextMeasuredBy === 'provider',
+                                windowAssumed: event.windowSource !== 'provider' && event.windowSource !== 'config',
+                            },
+                        }
+                        : {}),
+                });
                 break;
-            case 'task':
-                pushMessage('tool', event.subject, false, event.status === 'completed' ? '☑' : '☐');
+            case 'reasoning': {
+                if (event.done)
+                    break;
+                setState('thinking');
+                // The last line only, bounded: a screen-wide row that changes as
+                // the model writes is a spinner with words, not a transcript.
+                setThinking((prev) => {
+                    const joined = `${prev ?? ''}${event.text}`;
+                    const lastLine = joined.slice(joined.lastIndexOf('\n') + 1);
+                    return lastLine.length > 160 ? `…${lastLine.slice(-159)}` : lastLine;
+                });
+                break;
+            }
+            case 'task': {
+                // The live list gets every change; the transcript records the
+                // opening and the close, as it did before the list existed.
+                // Decided from a ref, not inside the state updater: React runs
+                // updaters lazily, so a flag set there is still unset when the
+                // transcript row below is chosen.
+                const isNew = !knownTaskIdsRef.current.has(event.taskId);
+                knownTaskIdsRef.current.add(event.taskId);
+                const item = {
+                    id: event.taskId,
+                    subject: event.subject,
+                    status: event.status,
+                };
+                setTasks((prev) => {
+                    const index = prev.findIndex((task) => task.id === item.id);
+                    return index < 0 ? [...prev, item] : prev.map((task, i) => (i === index ? item : task));
+                });
+                if (event.status === 'completed') {
+                    pushMessage('tool', event.subject, false, '☑');
+                }
+                else if (event.status === 'failed') {
+                    pushMessage('tool', event.subject, false, '☒');
+                }
+                else if (isNew) {
+                    pushMessage('tool', event.subject, false, '☐');
+                }
+                break;
+            }
+            case 'job':
+                // The kernel saw it end during a turn; the model reads the notice
+                // on its next tool result, the operator reads this row.
+                pushMessage('system', describeJobExit(event), false, '⚙');
                 break;
             case 'context':
                 // Into the TRANSCRIPT, not a status line. A status indicator is
@@ -2592,6 +3035,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 // looking at was compacted. The event is a fact about the
                 // conversation and belongs in its record.
                 pushMessage('system', event.text, false, event.shed ? '⌫' : '⌦');
+                if (event.shed) {
+                    setCompactionTally((tally) => ({
+                        passes: tally.passes + 1,
+                        clearedResults: tally.clearedResults + (event.cleared ?? 0),
+                        stubbedNarrations: tally.stubbedNarrations + (event.stubbed ?? 0),
+                        summaries: tally.summaries + (event.summarised ? 1 : 0),
+                        reclaimedTokens: tally.reclaimedTokens + (event.reclaimedTokens ?? 0),
+                    }));
+                }
                 break;
             case 'provider-fallback':
                 // The transcript, for the reason compaction is in the transcript
@@ -2721,6 +3173,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         else {
             pushMessage('user', text, false, undefined, undefined, undefined, humanPromptMeta(attached.length, attachments));
         }
+        // A plan is scoped to the request it was made for. Cleared here, at
+        // the start of the next one, rather than when the previous turn
+        // ended: a finished list stays on screen until the operator moves on,
+        // which is the moment it has told them everything it can.
+        setTasks([]);
+        knownTaskIdsRef.current = new Set();
         // The model interleaves text → tool → text across iterations; `applyEvent`
         // renders each one in order.
         const st = {
@@ -2870,8 +3328,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     ...(goalRound ? { goalRound } : {}),
                     // The mode above decides whether this callback is consulted.
                     onPermission: askPermission,
+                    onQuestion: askQuestion,
                     inboundMessages: () => inbox.drain(),
-                    extraSystem: composeSkillsPrompt(activeSkills) ?? undefined,
+                    extraSystem: [composeSkillsPrompt(activeSkills), drainIdleJobNotices(), drainOperatorShell()]
+                        .filter((part) => Boolean(part))
+                        .join('\n\n') || undefined,
                     onConversationMessages: (messages) => {
                         // State-only: opaque reasoning/signatures must reach the next
                         // provider and durable store without becoming transcript text.
@@ -3089,6 +3550,41 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             return;
         }
         setHistory((prev) => [...prev, value]);
+        // `#` remembers, `!` runs — neither is a prompt. Both are the
+        // operator acting directly, the way other coding agents spell it,
+        // and both leave a row the model reads on its next turn.
+        if (value.startsWith('#') && value.slice(1).trim().length > 0) {
+            const note = value.slice(1).trim();
+            try {
+                const path = appendMemory(note, { scope: 'project', cwd: ctx.cwd });
+                pushMessage('system', `Remembered for this project (${path}): ${note}`);
+            }
+            catch (err) {
+                pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return;
+        }
+        const escaped = shellEscapeCommand(value);
+        if (escaped !== null) {
+            pushMessage('user', value);
+            const rowId = pushMessage('tool', `! ${escaped}`, true, '…');
+            void runShellEscape(escaped, { cwd: ctx.cwd }).then((result) => {
+                operatorShellRef.current.push(describeShellEscapeForModel(escaped, result));
+                const ok = result.exitCode === 0 && !result.timedOut;
+                const detail = result.output.length > 0 ? result.output.replace(/\n$/u, '').split('\n') : undefined;
+                setMessages((prev) => prev.map((m) => m.id === rowId
+                    ? {
+                        ...m,
+                        content: describeShellEscape(escaped, result),
+                        pending: false,
+                        glyph: ok ? '✓' : '✗',
+                        ...(ok ? {} : { glyphColor: theme.status.error }),
+                        ...(detail ? { detail } : {}),
+                    }
+                    : m));
+            });
+            return;
+        }
         // What actually gets sent. A `prompt` action replaces it with text the
         // command composed, and then takes the ordinary send path below —
         // including the queue — so a command-driven turn is not a second way
@@ -3116,6 +3612,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             description: command.problem
                                 ? `Unavailable: ${command.problem}`
                                 : command.description,
+                            disabledReason: command.problem,
                         })),
                         windowSize: suggestionWindowSize(terminal.rows),
                     });
@@ -3123,8 +3620,154 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 }
                 case 'agent-cockpit': {
                     if (!openAgentCockpit()) {
-                        pushMessage('system', 'No delegated agents are active. When an Agent tool starts one, its live activity appears below the composer and this view can inspect it.');
+                        pushMessage('system', `No delegated agents in this conversation.${session?.agentIds.length ? `\nAvailable: ${session.agentIds.join(', ')}` : '\nNo agents are configured.'}`);
+                    }
+                    return;
+                }
+                case 'settings-picker': {
+                    const commands = [
+                        {
+                            name: 'model',
+                            description: `${session?.providerSummary ?? 'No provider'} · ${session?.modelSummary ?? 'No model'}. Change model or provider.`,
+                        },
+                        {
+                            name: 'effort',
+                            description: `${reasoningEffortRef.current ?? session?.reasoningEffortDefault ?? 'Model default'} · applies to future turns in this session.`,
+                            ...(session?.reasoningEffortLevels === undefined
+                                ? { problem: 'This model does not publish reasoning choices.' }
+                                : {}),
+                        },
+                        {
+                            name: 'permissions',
+                            description: `${permissionModeRef.current} · applies to future turns in this session.`,
+                        },
+                        {
+                            name: 'status config',
+                            description: 'Show which configuration files and overrides are in use.',
+                        },
+                    ];
+                    setSelectedChoice(0);
+                    setChoicePicker({
+                        kind: 'command',
+                        title: 'Settings',
+                        notice: 'Select a setting to view or change it.',
+                        values: commands,
+                        options: commands.map((command) => ({
+                            label: `/${command.name}`,
+                            description: command.description,
+                            disabledReason: command.problem,
+                        })),
+                        windowSize: 7,
+                    });
+                    return;
+                }
+                case 'goal-editor': {
+                    const scope = scopeRef.current;
+                    if (!scope || !sessionsRef.current) {
+                        pushMessage('system', 'Goals require conversation history to be available.');
+                        return;
                     }
+                    textPromptTokenRef.current += 1;
+                    setTextPrompt({
+                        token: textPromptTokenRef.current,
+                        kind: slash.edit ? 'goal-edit' : 'goal-create',
+                        title: slash.edit ? 'Edit goal' : 'Set a goal',
+                        placeholder: `Up to ${goalStatus?.maxGoalRounds ?? DEFAULT_MAX_GOAL_ROUNDS} automatic turns; /goal pause stops continuation.`,
+                        emptyNotice: 'Describe the result you want, or press Esc to cancel.',
+                        initialValue: slash.edit ? (goalStatus?.objective ?? '') : '',
+                        sessionId: scope.sessionId,
+                    });
+                    return;
+                }
+                case 'goal-picker': {
+                    const generation = conversationGenRef.current;
+                    const request = {};
+                    setSelectedChoice(-1);
+                    setChoicePicker({
+                        kind: 'command',
+                        title: 'Goal',
+                        notice: 'Loading goal…',
+                        values: [],
+                        options: [],
+                        windowSize: 7,
+                        request,
+                    });
+                    void (async () => {
+                        try {
+                            const sessions = sessionsRef.current;
+                            const scope = scopeRef.current;
+                            if (!sessions || !scope) {
+                                setChoicePicker(null);
+                                pushMessage('system', 'Goals require conversation history to be available.');
+                                return;
+                            }
+                            const goal = conversationMaterializedRef.current
+                                ? await sessions.goals.getGoal(scope.sessionId, sessions.tenantId)
+                                : null;
+                            if (appLifetime.signal.aborted ||
+                                conversationGenRef.current !== generation ||
+                                choicePickerRef.current?.request !== request)
+                                return;
+                            setGoalStatus(goal);
+                            const commands = goal
+                                ? [
+                                    {
+                                        name: 'goal status',
+                                        description: 'View goal progress and continuation status.',
+                                    },
+                                    { name: 'goal edit', description: 'Change the objective.' },
+                                    ...(goal.phase === 'complete'
+                                        ? []
+                                        : [
+                                            goal.phase === 'active' && goalActivation.isArmed(scope.sessionId, goal)
+                                                ? {
+                                                    name: 'goal pause',
+                                                    description: 'Stop automatic continuation after the current turn.',
+                                                }
+                                                : {
+                                                    name: 'goal resume',
+                                                    description: 'Continue working automatically toward this goal.',
+                                                },
+                                        ]),
+                                    {
+                                        name: 'goal clear',
+                                        description: 'Remove this goal and stop its automatic continuation.',
+                                    },
+                                ]
+                                : [
+                                    {
+                                        name: 'goal set',
+                                        description: 'Set an objective and start automatic continuation.',
+                                    },
+                                ];
+                            setSelectedChoice(0);
+                            setChoicePicker({
+                                kind: 'command',
+                                back: choicePickerRef.current?.back,
+                                title: 'Goal',
+                                notice: goal
+                                    ? `${goal.phase} · ${goal.roundsAdmitted}/${goal.maxGoalRounds} automatic turns · ${goal.objective}`
+                                    : `No goal set for this conversation. Up to ${DEFAULT_MAX_GOAL_ROUNDS} automatic turns when started.`,
+                                values: commands,
+                                options: commands.map((command) => ({
+                                    label: `/${command.name}`,
+                                    description: command.description,
+                                })),
+                                windowSize: 7,
+                            });
+                        }
+                        catch (error) {
+                            if (!appLifetime.signal.aborted &&
+                                conversationGenRef.current === generation &&
+                                choicePickerRef.current?.request === request) {
+                                setChoicePicker(null);
+                                pushMessage('system', `Could not load goal: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                        finally {
+                            wakeGoalDriver();
+                        }
+                    })();
                     return;
                 }
                 case 'clear-screen':
@@ -3196,7 +3839,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     setKeyEntryFor(null);
                     setPickerDetected(null);
                     setPickerSelectionKind('provider-and-model');
-                    setPickerInitialView('providers');
+                    setPickerInitialView('models');
                     setPhase('picker');
                     return;
                 case 'permission-mode': {
@@ -3218,7 +3861,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         pushMessage('system', 'Permission choices are unavailable until the active turn, prompt, compaction, queued work, or embedded-session approval latch can be safely settled.');
                         return;
                     }
-                    const values = ['prompt', 'auto', 'strict'];
+                    const values = ['prompt', 'accept-edits', 'auto', 'strict', 'plan'];
                     setSelectedChoice(Math.max(0, values.indexOf(permissionModeRef.current)));
                     setChoicePicker({
                         kind: 'permission-mode',
@@ -3263,6 +3906,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             label: effort ?? 'default',
                             description: reasoningEffortDescription(effort),
                             current: effort === current,
+                            default: effort === undefined,
                         })),
                     });
                     return;
@@ -3304,16 +3948,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 }
                 case 'remember':
                     try {
-                        appendMemory(slash.text);
-                        pushMessage('system', `Remembered: ${slash.text}`);
+                        const path = appendMemory(slash.text, { scope: slash.scope, cwd: ctx.cwd });
+                        pushMessage('system', `Remembered ${slash.scope === 'user' ? 'for every project' : 'for this project'} (${path}): ${slash.text}`);
                     }
                     catch (err) {
                         pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
                     }
                     return;
                 case 'show-memory': {
-                    const mem = composeMemoryPrompt(readMemory());
-                    pushMessage('system', mem ?? 'Nothing remembered yet. Use /remember <text>, or edit ~/.namzu/MEMORY.md.');
+                    const mem = composeMemoryPrompt(readMemory(undefined, ctx.cwd));
+                    pushMessage('system', mem ??
+                        'Nothing remembered yet. #note or /memory <text> saves a fact about this project (.namzu/MEMORY.md); /memory --user <text> saves one for every project (~/.namzu/MEMORY.md).');
                     return;
                 }
                 case 'list-skills': {
@@ -3372,79 +4017,19 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 case 'fork':
                     void doFork();
                     return;
-                case 'expand': {
-                    // Resolved INSIDE the updater, against `prev`.
-                    //
-                    // Not against the `messages` this callback captured: rows arrive
-                    // from `applyEvent` while a turn runs, which is exactly when
-                    // someone types `/expand`, and a captured array can be a render
-                    // behind — so "the most recent one" would sometimes mean the one
-                    // before it, and the command would quietly show the wrong output.
-                    // `prev` is by definition the latest.
-                    //
-                    // And against the ROWS, not a parallel index of them. An earlier
-                    // draft kept a ref mirroring `{ref, label, lines}` alongside the
-                    // rows that already hold all three. That is one concept in two
-                    // shapes with a hand-written copy between them — the geometry
-                    // `docs/conventions/one-site-is-not-every-site.md` names as the
-                    // hardest kind to spot, adopted here to solve a staleness problem
-                    // the updater solves without it.
-                    //
-                    // The id is taken outside so both branches use the same one.
-                    const id = nextId();
-                    setMessages((prev) => {
-                        const blocks = prev.filter((m) => m.detailRef !== undefined);
-                        const say = (content) => ({
-                            id,
-                            role: 'system',
-                            content,
-                        });
-                        if (blocks.length === 0) {
-                            return [
-                                ...prev,
-                                say('Nothing to expand yet. Tool output longer than six lines collapses with a "… +N lines · /expand n" hint, and that number is what this takes.'),
-                            ];
-                        }
-                        const block = slash.which === 'last'
-                            ? blocks[blocks.length - 1]
-                            : blocks.find((m) => m.detailRef === slash.which);
-                        if (!block) {
-                            // Names the range rather than only refusing: the operator's
-                            // next move is to type a different number, and they should
-                            // not have to guess which ones exist.
-                            return [
-                                ...prev,
-                                say(`No collapsed output numbered ${slash.which}. This conversation has ${blocks.length === 1
-                                    ? 'one, numbered 1'
-                                    : `${blocks.length}, numbered 1 to ${blocks.length}`}.`),
-                            ];
-                        }
-                        // A NEW row carrying the same lines, flagged to print them all.
-                        // Not a mutation of the row that collapsed them: that row was
-                        // handed to <Static>, which emits an item once and calls the
-                        // render function only for items it has not emitted yet, so
-                        // nothing decided now can reach it. Appending is the only
-                        // expansion this architecture has.
-                        //
-                        // The lines travel as `detail` rather than flattened into the
-                        // content so the `▏` rule and the +/- diff colouring survive.
-                        // An expansion that showed LESS than the collapsed form would
-                        // be a strange thing to have asked for.
-                        //
-                        // It carries no `detailRef` of its own: it is already in full,
-                        // so there is nothing for a number to offer, and giving it one
-                        // would let `/expand` produce a third copy of the same output.
-                        return [
-                            ...prev,
-                            {
-                                id,
-                                role: 'system',
-                                content: `${block.content} — in full (${block.detail?.length ?? 0} lines)`,
-                                glyph: '⤢',
-                                detail: block.detail,
-                                detailExpanded: true,
-                            },
-                        ];
+                case 'restore':
+                    void doRestore(slash.turn);
+                    return;
+                case 'add-dir': {
+                    const dirs = session?.directories;
+                    if (!dirs) {
+                        pushMessage('system', 'No session yet; /add-dir works once one has started.');
+                        return;
+                    }
+                    void dirs.add(slash.path).then((result) => {
+                        pushMessage('system', result.added
+                            ? `Added ${result.path}. The file tools reach it by absolute path from the next turn; a sandboxed run binds it read-write.`
+                            : `Not added: ${result.path} — ${result.reason ?? 'refused'}`);
                     });
                     return;
                 }
@@ -3479,9 +4064,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                 await materializeConversation();
                             const durableSessions = sessionsRef.current;
                             const runScope = scopeRef.current;
+                            const taskStore = slash.name === 'tasks' ? session?.currentTaskStore?.() : undefined;
+                            if (slash.name === 'tasks' && !taskStore) {
+                                pushMessage('system', session?.currentTaskStore
+                                    ? 'No task list is available yet for this conversation.'
+                                    : 'Task listing is unavailable in this session.');
+                                return;
+                            }
                             const registry = new HostCommandRegistry();
                             registry.register(kernelHostCommands({
                                 allowedAgentIds: session?.agentIds ?? [],
+                                ...(taskStore ? { taskStore } : {}),
                                 ...(durableSessions && runScope && conversationMaterializedRef.current
                                     ? {
                                         goal: {
@@ -3781,11 +4374,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         advanceQueueContinuation,
         applyPermissionMode,
         applyReasoningEffort,
+        appLifetime,
         ctx.cwd,
         doResume,
         enqueueQueued,
         exitWithSummary,
         hasUnsettledTurn,
+        goalActivation,
+        goalStatus,
+        hostCommands,
         nextId,
         openAgentCockpit,
         pushMessage,
@@ -3793,6 +4390,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         removeStoredCredential,
         resetTranscript,
         runConversationExport,
+        session,
         setChoicePicker,
         setCopyPicker,
         setReasoningEffort,
@@ -4001,9 +4599,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', `⬆ Update available:\n${lines.join('\n')}`);
         });
     }, [phase, ctx.version, pushMessage]);
-    const hydrateFromPicker = useCallback(async (prefs, detectedNow, signal, revealAllOnFailure = false) => {
+    const hydrateFromPicker = useCallback(async (prefs, detectedNow, signal, options = {}) => {
         try {
-            await hydrateSession(prefs, detectedNow, signal);
+            await hydrateSession(prefs, detectedNow, signal, options.persistSelection);
         }
         catch (err) {
             // A superseded choice no longer owns even its failure message. Its
@@ -4011,7 +4609,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // choice stays on the picker with the actionable construction error.
             if (signal.aborted)
                 return;
-            if (revealAllOnFailure) {
+            if (options.revealAllOnFailure) {
                 setPickerDetected(null);
                 setPickerSelectionKind('provider-and-model');
                 setPickerInitialView('providers');
@@ -4036,48 +4634,29 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         setPickerNotice(null);
         // The disposition, not the key. `credential` never reaches a message.
         pushMessage('system', disposition);
-        // The SAVED chain when the credential is for the provider that was
-        // already chosen, and a fresh one-member chain otherwise. Rebuilding
-        // from the id alone would have been a quiet demotion in the one case
-        // this routing creates: an operator whose file pins a model, and whose
-        // only problem was a missing secret, would have been moved onto the
-        // registry default for supplying it.
+        // Supplying a credential changes the primary's access, not unrelated
+        // fallbacks, model pins, delegation or capability preferences.
         const saved = savedPrefsRef.current;
         const prefs = saved && primaryProvider(saved).id === credential.entry.id
             ? saved
-            : {
-                version: 3,
-                providers: [{ id: credential.entry.id }],
-                subagents: { active: [] },
-            };
+            : selectPrimaryProvider(saved, { id: credential.entry.id });
         void hydrateFromPicker(prefs, next, signal);
     }, [detected, hydrateFromPicker, pushMessage]);
     const handlePickerSubmit = useCallback((selection, signal) => {
-        // One member for now. The picker builds a longer chain in a later
-        // change; the shape it writes into is already the chain.
-        const prefs = {
-            version: 3,
-            providers: [
-                {
-                    id: selection.provider,
-                    ...(selection.model !== undefined ? { model: selection.model } : {}),
-                },
-            ],
-            subagents: { active: [] },
-        };
+        const prefs = selectPrimaryProvider(savedPrefsRef.current, {
+            id: selection.provider,
+            ...(selection.model !== undefined ? { model: selection.model } : {}),
+        });
         setKeyEntryFor(null);
         setPickerNotice(null);
-        try {
-            writePreferences(prefs);
-        }
-        catch (err) {
-            pushMessage('system', `Could not save preferences: ${err instanceof Error ? err.message : String(err)}`);
-            return;
-        }
         // Keep a narrowed signed-in roster stable while construction is pending.
         // Only a real refusal broadens back to the general, sign-in-capable picker.
-        void hydrateFromPicker(prefs, detected, signal, true);
-    }, [detected, hydrateFromPicker, pushMessage]);
+        void hydrateFromPicker(prefs, detected, signal, {
+            revealAllOnFailure: true,
+            persistSelection: detected.find((provider) => provider.entry.id === selection.provider)?.source.kind !==
+                'session',
+        });
+    }, [detected, hydrateFromPicker]);
     /**
      * Leaving the picker returns to whatever was on screen before it.
      *
@@ -4107,6 +4686,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         exitWithSummary();
     }, [session, exitWithSummary]);
     useInput((input, key) => {
+        // Startup has refused admission, so there is no draft or active turn to
+        // protect with the ready screen's two-press exit ladder.
+        if (phase === 'unhealthy') {
+            if (key.escape || (key.ctrl && input === 'c'))
+                exitWithSummary();
+            return;
+        }
         // The provider picker owns its own keyboard — arrows, digits, enter,
         // esc and the typed-key screen are all its business. Ctrl+C is not: it
         // is the one key that must work on every screen, and this handler used
@@ -4124,12 +4710,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 exitWithSummary();
             return;
         }
-        // Previous-prompt picker owns the keyboard. Esc keeps stepping toward
-        // older prompts, matching the second Esc that opened it; q is the cancel.
+        // Previous-prompt picker uses the same cancel key as other selectors.
         if (phase === 'edit') {
             if (editCommittedRef.current)
                 return;
-            if ((key.ctrl && input === 'c') || input.toLowerCase() === 'q') {
+            if (key.escape || (key.ctrl && input === 'c') || input.toLowerCase() === 'q') {
                 setEditList([]);
                 setPhase('ready');
                 return;
@@ -4138,7 +4723,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setSelectedEdit((index) => moveSelection(index, editList.length, key.home ? 'first' : key.end ? 'last' : key.pageUp ? 'previous-page' : 'next-page'));
                 return;
             }
-            if (key.escape || key.leftArrow || key.upArrow) {
+            if (key.leftArrow || key.upArrow) {
                 setSelectedEdit((index) => moveSelection(index, editList.length, 'previous'));
                 return;
             }
@@ -4212,25 +4797,27 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setPermissionDetailsOpen(!permissionDetailsOpenRef.current);
                 return;
             }
-            if (permission &&
-                (key.upArrow || key.downArrow || key.pageUp || key.pageDown || key.home || key.end)) {
+            if (permission && (key.upArrow || key.downArrow)) {
+                const current = permissionChoiceRef.current;
+                const next = key.upArrow ? Math.max(0, current - 1) : Math.min(2, current + 1);
+                setPermissionChoice(next);
+                return;
+            }
+            if (permission && (key.pageUp || key.pageDown || key.home || key.end)) {
                 const source = permissionDetailsOpenRef.current
                     ? permission.review
                     : permission.summary.text;
                 const count = permissionReviewRows(source, terminal.columns).length;
-                const maxOffset = Math.max(0, count - PERMISSION_REVIEW_PAGE_ROWS);
+                const pageRows = permissionReviewPageRows(terminal.rows);
+                const maxOffset = Math.max(0, count - pageRows);
                 const current = Math.min(permissionReviewOffsetRef.current, maxOffset);
                 const next = key.home
                     ? 0
                     : key.end
                         ? maxOffset
                         : key.pageUp
-                            ? Math.max(0, current - PERMISSION_REVIEW_PAGE_ROWS)
-                            : key.pageDown
-                                ? Math.min(maxOffset, current + PERMISSION_REVIEW_PAGE_ROWS)
-                                : key.upArrow
-                                    ? Math.max(0, current - 1)
-                                    : Math.min(maxOffset, current + 1);
+                            ? Math.max(0, current - pageRows)
+                            : Math.min(maxOffset, current + pageRows);
                 setPermissionReviewOffset(next);
                 return;
             }
@@ -4245,18 +4832,21 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 resolvePermission({ kind: 'reject' });
                 return;
             }
-            // Enter is deliberately NOT an approval. It is the key people press
-            // to dismiss a thing that appeared, it is the key already in flight
-            // when a turn's follow-up was being typed, and it is named nowhere
-            // on this prompt — so reading it as consent approves a tool call the
-            // operator never looked at. `y` and `a` are the only approvals, and
-            // they must arrive after the prompt has been up long enough to read.
+            // Every approval waits out the settle window: `y`, `a`, a digit and
+            // Enter alike. Enter confirms the answer the cursor is on, which
+            // opens on "Yes" — the prompt an operator knows from elsewhere — so
+            // the window is what stands between an in-flight Enter and a call
+            // the operator never looked at. Refusals above never wait.
             if (!approvalIsDeliberate(permissionOpenedAtRef.current, Date.now()))
                 return;
-            if (ch === 'y')
+            const numbered = ch === '1' ? 0 : ch === '2' ? 1 : ch === '3' ? 2 : null;
+            const chosen = key.return ? permissionChoiceRef.current : numbered;
+            if (ch === 'y' || chosen === 0)
                 resolvePermission({ kind: 'approve' });
-            else if (ch === 'a')
+            else if (ch === 'a' || chosen === 1)
                 resolvePermission({ kind: 'approve-all' });
+            else if (chosen === 2)
+                resolvePermission({ kind: 'reject' });
             return;
         }
         // The active child count already advertises this key beside Working.
@@ -4406,33 +4996,61 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // menu. Only the exact object React committed may consume a choice.
             if (choicePickerCommittedRef.current !== picker)
                 return;
-            const options = picker.options;
+            const searchable = choicePickerSearchable(picker);
+            const options = filterChoiceOptions(picker.options, choiceQueryRef.current);
+            const applyVisibleChoice = (index) => {
+                const option = options[index];
+                if (option)
+                    applyChoiceSelection(picker.options.indexOf(option));
+            };
             if (key.escape || (key.ctrl && input === 'c')) {
                 reviewChoiceInFlightRef.current = null;
-                setChoicePicker(null);
+                setSelectedChoice(0);
+                setChoicePicker(key.escape ? (picker.back ?? null) : null);
+                // Esc leaves the question unanswered and the turn running; the
+                // tool tells the model so. Ctrl+C is the operator saying stop.
+                if (picker.kind === 'user-question') {
+                    resolveQuestion({ kind: key.escape ? 'skip' : 'abort' });
+                }
                 return;
             }
             if (key.home || key.end || key.pageUp || key.pageDown) {
-                const pageSize = picker.kind === 'command' ? picker.windowSize : undefined;
-                setSelectedChoice((index) => moveSelection(index, options.length, key.home ? 'first' : key.end ? 'last' : key.pageUp ? 'previous-page' : 'next-page', pageSize));
+                const pageSize = choicePickerWindowSize({
+                    rows: terminal.rows,
+                    columns: Math.max(1, (terminal.columns ?? 80) - 2),
+                    searchable,
+                    notice: Boolean(picker.notice),
+                    selectedDescription: options.some((option) => Boolean(option.selectedDescription || option.disabledReason)),
+                    windowSize: picker.kind === 'command' ? picker.windowSize : undefined,
+                });
+                setSelectedChoice((index) => moveChoiceSelection(options, index, key.home ? 'first' : key.end ? 'last' : key.pageUp ? 'previous-page' : 'next-page', pageSize));
                 return;
             }
             if (key.upArrow) {
-                setSelectedChoice((index) => moveSelection(index, options.length, 'previous'));
+                setSelectedChoice((index) => moveChoiceSelection(options, index, 'previous'));
                 return;
             }
             if (key.downArrow) {
-                setSelectedChoice((index) => moveSelection(index, options.length, 'next'));
+                setSelectedChoice((index) => moveChoiceSelection(options, index, 'next'));
                 return;
             }
             if (key.return) {
-                applyChoiceSelection(selectedChoiceRef.current);
+                applyVisibleChoice(selectedChoiceRef.current);
+                return;
+            }
+            if (searchable && !key.ctrl && !key.meta && (key.backspace || key.delete || input)) {
+                const next = key.backspace || key.delete
+                    ? eraseLastChoiceGrapheme(choiceQueryRef.current)
+                    : choiceQueryRef.current + input.replace(/\p{Cc}/gu, '');
+                choiceQueryRef.current = next;
+                setChoiceQuery(next);
+                setSelectedChoice(moveChoiceSelection(filterChoiceOptions(picker.options, next), 0, 'first'));
                 return;
             }
             if (/^[1-9]$/.test(input)) {
                 const index = Number(input) - 1;
                 if (options[index])
-                    applyChoiceSelection(index);
+                    applyVisibleChoice(index);
             }
             return;
         }
@@ -4511,19 +5129,36 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // in place and sometimes prints a second copy further down would be two
         // commands wearing one name.
         if (key.ctrl && input === 'o') {
-            // Taken outside the updater so both branches use the same one, as
-            // `/expand` does.
+            // Taken outside the updater so both branches use the same one.
             const id = nextId();
             setMessages((prev) => {
                 const live = prev.filter((m) => !m.pending).slice(settledRef.current);
                 const collapsible = live.filter((m) => willCollapse(m.detail));
                 if (collapsible.length === 0) {
+                    // Nothing redrawable is collapsed, so this reprints the most recent
+                    // collapsed body as a new row — the rows above have been printed
+                    // to the terminal's own scrollback, which cannot be rewritten.
+                    const blocks = prev.filter((m) => m.detailRef !== undefined);
+                    const block = blocks[blocks.length - 1];
+                    if (!block) {
+                        return [
+                            ...prev,
+                            {
+                                id,
+                                role: 'system',
+                                content: 'Nothing to expand yet. Tool output longer than six lines collapses with a "… +N lines · ctrl+o" hint; Ctrl+O opens it in place while it is still on screen, and reprints the most recent one in full once it has scrolled away.',
+                            },
+                        ];
+                    }
                     return [
                         ...prev,
                         {
                             id,
                             role: 'system',
-                            content: 'Nothing on screen can be expanded in place. Only the last few rows stay redrawable; anything older has been printed to the terminal’s own scrollback, which cannot be rewritten. Use /expand <n> for those — the number is in the hint under each collapsed body, and /expand on its own takes the most recent.',
+                            content: `${block.content} — in full (${block.detail?.length ?? 0} lines)`,
+                            glyph: '⤢',
+                            detail: block.detail,
+                            detailExpanded: true,
                         },
                     ];
                 }
@@ -4612,21 +5247,28 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                 : agentSurface?.kind === 'transcript'
                                     ? 'observing agent — esc agents · q parent'
                                     : textPrompt
-                                        ? 'name editor open — enter save · esc cancel'
+                                        ? 'editor open · enter apply · esc cancel'
                                         : choicePicker
-                                            ? 'choice open — ↑↓ / 1–9 select · enter apply · esc cancel'
+                                            ? choicePickerSearchable(choicePicker)
+                                                ? 'type to filter · ↑↓ select · enter apply · esc back'
+                                                : '↑↓ / 1–9 select · enter apply · esc back'
                                             : copyPicker
                                                 ? 'copy target open — ↑↓ / 1–9 select · esc cancel'
                                                 : goalStatus && phase === 'ready' && state === 'idle'
                                                     ? undefined
                                                     : hintForPhase(phase, state, session?.hasProvider === true, composerHasDraft);
-    return (_jsx(Box, { flexDirection: "column", display: externalEditorRequest ? 'none' : 'flex', children: _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [transcriptOwned || !lifecycleOwnsViewport ? (_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: renderedSettled, resetKey: resetKey, raw: rawOutput, hyperlinks: hyperlinks, showLive: !lifecycleOwnsViewport, header: transcriptOwned ? (_jsx(Banner, { version: ctx.version, session: session, permissionMode: permissionMode, cwd: ctx.cwd })) : undefined }) })) : null, 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: [agentSurface === null ? (_jsx(LiveActivity, { activeTools: visibleActiveTools, working: state === 'thinking' || state === 'tool', interruptible: abortRef.current !== null, animate: stdout.isTTY === true })) : null, permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls, review: permission.review, summary: permission.summary, detailsOpen: permissionDetailsOpen, reviewOffset: permissionReviewOffset, columns: terminal.columns })) : null, textPrompt ? (_jsx(TextPrompt, { title: textPrompt.title, placeholder: textPrompt.placeholder, initialValue: textPrompt.initialValue, emptyNotice: textPrompt.emptyNotice, hidden: permission !== null || agentSurface !== null, onSubmit: submitTextPrompt, onCancel: cancelTextPrompt }, textPrompt.token)) : permission === null && agentSurface === null && choicePicker ? (_jsx(ChoicePicker, { title: choicePicker.title, notice: choicePicker.notice, options: choicePicker.options, selected: selectedChoice, windowSize: choicePicker.kind === 'command' ? choicePicker.windowSize : undefined })) : permission === null && agentSurface === null && copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { focus: state === 'idle' &&
-                                phase === 'ready' &&
+    return (_jsx(Box, { flexDirection: "column", display: externalEditorRequest ? 'none' : 'flex', children: _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: transcriptOwned ? renderedSettled : 0, resetKey: resetKey, raw: rawOutput, hyperlinks: hyperlinks, showLive: !lifecycleOwnsViewport, header: transcriptOwned ? (_jsx(BrandHeader, { version: ctx.version, provider: session?.providerSummary, model: session?.modelSummary, permissionMode: permissionMode, cwd: ctx.cwd })) : undefined }) }), phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'unhealthy' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.status.error, bold: true, children: "Startup stopped" }), _jsx(Text, { color: theme.text.secondary, children: "Resolve the error above, then restart Namzu." })] })) : 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: [agentSurface === null ? (_jsx(LiveActivity, { compact: compactWork, activeTools: visibleActiveTools, working: state === 'thinking' || state === 'tool', interruptible: abortRef.current !== null, animate: stdout.isTTY === true, thinking: thinking })) : null, agentSurface === null && permission === null ? (_jsx(TaskList, { tasks: tasks, compact: compactWork })) : null, permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls, review: permission.review, summary: permission.summary, detailsOpen: permissionDetailsOpen, reviewOffset: permissionReviewOffset, choice: permissionChoice, columns: terminal.columns, rows: terminal.rows })) : null, textPrompt ? (_jsx(TextPrompt, { title: textPrompt.title, placeholder: textPrompt.placeholder, initialValue: textPrompt.initialValue, emptyNotice: textPrompt.emptyNotice, hidden: permission !== null || agentSurface !== null, onSubmit: submitTextPrompt, onCancel: cancelTextPrompt }, textPrompt.token)) : permission === null && agentSurface === null && choicePicker ? (_jsx(ChoicePicker, { columns: Math.max(1, (terminal.columns ?? 80) - 2), title: choicePicker.title, notice: choicePicker.notice, options: filterChoiceOptions(choicePicker.options, choiceQuery), query: choicePickerSearchable(choicePicker) ? choiceQuery : undefined, selected: selectedChoice, windowSize: choicePicker.kind === 'command' ? choicePicker.windowSize : undefined })) : permission === null && agentSurface === null && copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { working: state === 'thinking' || state === 'tool' || visibleActiveTools.length > 0, focus: phase === 'ready' &&
+                                state !== 'awaiting-permission' &&
+                                !compacting &&
+                                externalEditorRequest === null &&
                                 conversationMutation === null &&
                                 textPrompt === null &&
                                 choicePicker === null &&
                                 copyPicker === null &&
-                                agentSurface === null, hidden: permission !== null || choicePicker !== null || copyPicker !== null, children: [pendingSteers.length > 0 &&
+                                agentSurface === null, hidden: permission !== null ||
+                                textPrompt !== null ||
+                                choicePicker !== null ||
+                                copyPicker !== null, children: [pendingSteers.length > 0 &&
                                     permission === null &&
                                     textPrompt === null &&
                                     choicePicker === null &&
@@ -4640,7 +5282,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                                 ? queuePause.outcome === 'paused'
                                                     ? 'held after a resumable run paused; wait for recovery, change model, or send a message to release it'
                                                     : `paused after a ${queuePause.outcome} turn; send a message or change model to continue`
-                                                : 'sending when ready'] }) })) : null, _jsx(Composer, { disabled: phase !== 'ready' ||
+                                                : 'sending when ready'] }) })) : null, _jsx(Composer, { permissionMode: permissionMode, onCycleMode: cyclePermissionMode, disabled: phase !== 'ready' ||
                                         state === 'awaiting-permission' ||
                                         compacting ||
                                         conversationMutation !== null ||
@@ -4651,26 +5293,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                         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), onStepReasoningEffort: stepReasoningEffort, onExternalEdit: requestExternalEditor, onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), onDraftPresenceChange: setComposerHasDraft, onOpenAgentPanel: openAgentCockpit, userCommands: userCommands, mentionCandidates: mentionCandidates, history: history })] }), permission === null && agentSurface === null && liveSubagents.length > 0 ? (_jsx(AgentTaskPanel, { agents: liveSubagents, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : permission === null && agentSurface?.kind === 'cockpit' ? (_jsx(AgentCockpit, { agents: liveSubagents, selectedPhaseId: agentSurface.selectedPhaseId, selectedId: agentSurface.selectedId, focus: agentSurface.focus, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : permission === null && agentSurface?.kind === 'transcript' && selectedSubagent ? (_jsx(AgentTranscript, { agent: selectedSubagent, tailOffset: agentSurface.tailOffset, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : null] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort ?? 'default', goal: statusGoal, state: state, hint: statusHint }) })] }) }));
+                                    escapeInterrupts: !compacting && (state === 'thinking' || state === 'tool'), onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), onStepReasoningEffort: stepReasoningEffort, onExternalEdit: requestExternalEditor, onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), onDraftPresenceChange: setComposerHasDraft, onOpenAgentPanel: openAgentCockpit, userCommands: userCommands, builtins: hostCommands.map((command) => ({
+                                        ...command,
+                                        description: command.unavailable?.(slashCtx) ?? command.description,
+                                    })), mentionCandidates: mentionCandidates, history: history })] }), permission === null && agentSurface === null && liveSubagents.length > 0 ? (_jsx(AgentTaskPanel, { agents: liveSubagents, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : permission === null && agentSurface?.kind === 'cockpit' ? (_jsx(AgentCockpit, { agents: liveSubagents, selectedPhaseId: agentSurface.selectedPhaseId, selectedId: agentSurface.selectedId, focus: agentSurface.focus, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : permission === null && agentSurface?.kind === 'transcript' && selectedSubagent ? (_jsx(AgentTranscript, { agent: selectedSubagent, tailOffset: agentSurface.tailOffset, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : null] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort ?? 'default', goal: statusGoal, state: state, hint: statusHint }) })] }) }));
 }
-function Banner({ version, session, permissionMode, cwd, }) {
-    const { columns } = useWindowSize();
-    const wide = columns >= NAMZU_WORDMARK_MIN_WIDTH;
-    const provider = session?.providerSummary;
-    const model = session?.modelSummary;
-    const home = process.env.HOME;
-    const prettyCwd = home && cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd;
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, paddingBottom: 1, children: [_jsxs(Box, { flexDirection: "row", children: [wide ? (_jsx(Box, { flexDirection: "column", marginRight: 2, children: NAMZU_WORDMARK.map((line, i) => (_jsx(Text, { color: NAMZU_WORDMARK_GRADIENT[i], bold: true, children: line }, `wm-${i}`))) })) : (_jsxs(Text, { color: NAMZU_MARK_COLOR, children: [NAMZU_MARK, " "] })), _jsxs(Box, { flexDirection: "column", marginTop: wide ? 1 : 0, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.text.secondary, children: "Cogitave" }), wide ? null : (_jsxs(Text, { color: NAMZU_MARK_COLOR, bold: true, children: [' ', "Namzu"] })), _jsxs(Text, { color: theme.text.muted, children: [" v", version] })] }), _jsx(Text, { color: theme.text.secondary, children: provider ? `${provider}${model ? ` · ${model}` : ''}` : 'the agent in your terminal' }), _jsx(Text, { color: theme.text.muted, children: prettyCwd })] })] }), permissionMode === 'auto' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, bold: true, children: "\u26A0 launched in auto permission mode \u2014 undecided tools run without asking until /permissions changes it" }) })) : null] }));
+/** One line for a background job that ended, for the transcript and the next turn. */
+function describeJobExit(job) {
+    const outcome = job.status === 'killed'
+        ? 'was stopped'
+        : `exited ${job.exitCode ?? '?'}${job.signal ? ` (${job.signal})` : ''}`;
+    return `background job ${job.jobId} (${job.command}) ${outcome}`;
 }
 function TranscriptFrame({ children }) {
     // Borderless, edge-to-edge — the message glyph gutter provides structure.
     return _jsx(Box, { flexDirection: "column", children: children });
 }
-function ComposerFrame({ focus, hidden = false, children, }) {
-    // Input-field look: a rounded rule above and below the composer, no side
-    // borders, so the input reads as a field rather than a heavy box.
-    return (_jsx(Box, { flexDirection: "column", ...(hidden ? {} : { borderStyle: 'round' }), borderTop: true, borderBottom: true, borderLeft: false, borderRight: false, borderColor: focus ? theme.border.focus : theme.border.default, marginTop: hidden ? 0 : 1, children: children }));
-}
 // Tool call label: the tool name title-cased, then its most identifying
 // argument — `Bash(ls -la)`, `Read(file.ts)`. A bare tool name in a transcript
 // of forty calls says nothing about which one this was.
@@ -4693,7 +5331,7 @@ hasDraft = false) {
     if (phase === 'resume')
         return '↑↓ navigate · enter resume · esc cancel';
     if (phase === 'edit')
-        return 'Esc / ← older · → newer · enter fork and edit · q cancel';
+        return '← older · → newer · enter fork and edit · esc cancel';
     if (phase === 'probing')
         return 'discovering providers…';
     // Esc does two different things here depending on how the picker was reached,
@@ -4705,11 +5343,11 @@ hasDraft = false) {
             : '↑↓ navigate · enter accept · esc or Ctrl+C exit';
     }
     if (phase === 'unhealthy')
-        return 'Ctrl+C ×2 to exit';
+        return 'esc or Ctrl+C exit';
     // Enter is absent because Enter decides nothing here, deliberately — see the
     // permission gate in the key handler above.
     if (state === 'awaiting-permission')
-        return 'y approve · n / esc reject · a approve all';
+        return '↑↓ select · enter confirm · esc decline';
     if (state !== 'idle')
         return hasDraft ? 'enter steer · tab queue · esc interrupt' : '';
     // The composer already points to /help. Keeping the complete key legend in
@@ -4731,15 +5369,12 @@ function goalStatusLabel(goal) {
             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';
-    }
+/** The label the operator saw for the option id they chose. */
+function labelOfOption(question, optionId) {
+    return question.options.find((option) => option.id === optionId)?.label ?? optionId;
+}
+function choicePickerSearchable(picker) {
+    return ['command', 'skill', 'review-branch', 'review-commit'].includes(picker.kind);
 }
 function permissionPickerNotice(session) {
     const notices = [];