@namzu/cli 18.0.0 → 18.1.0

package/dist/tui/App.js

@@ -34,6 +34,7 @@ import { Composer, suggestionWindowSize, } from './Composer.js';
 import { CopyPicker } from './CopyPicker.js';
 import { EditPromptPicker } from './EditPromptPicker.js';
 import { LiveActivity, formatElapsed } from './LiveActivity.js';
+import { TaskList } from './TaskList.js';
 import { PermissionOverlay } from './PermissionOverlay.js';
 import { Picker } from './Picker.js';
 import { ResumePicker } from './ResumePicker.js';
@@ -57,12 +58,36 @@ import { PERMISSION_REVIEW_PAGE_ROWS, buildPermissionReview, buildPermissionSumm
 import { describeRunInterruption } from './run-interruption.js';
 import { moveSelection } from './selection-window.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';
+/** 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) {
@@ -292,6 +317,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);
@@ -329,6 +370,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // 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);
     /**
@@ -1027,6 +1077,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)
@@ -1209,6 +1273,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({
@@ -1348,12 +1445,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));
@@ -1452,7 +1572,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             ...(sessionsRef.current ? { sessionGoals: sessionsRef.current.goals } : {}),
             ...(activeCtx.mcpServers ? { mcpServers: activeCtx.mcpServers } : {}),
             ...(activeCtx.plugins ? { plugins: activeCtx.plugins } : {}),
+            ...(activeCtx.web ? { web: activeCtx.web } : {}),
             ...(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();
@@ -2243,6 +2367,19 @@ 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'
@@ -2275,8 +2412,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.
      *
@@ -2461,6 +2601,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
@@ -2491,6 +2664,10 @@ 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();
                 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,7 +2678,21 @@ 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': {
@@ -2582,9 +2773,34 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             case 'usage':
                 setUsage({ totalTokens: event.totalTokens, cost: event.cost });
                 break;
-            case 'task':
-                pushMessage('tool', event.subject, false, event.status === 'completed' ? '☑' : '☐');
+            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 'context':
                 // Into the TRANSCRIPT, not a status line. A status indicator is
                 // present while nothing is happening and gone afterwards, so
@@ -2721,6 +2937,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,6 +3092,7 @@ 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,
                     onConversationMessages: (messages) => {
@@ -3218,7 +3441,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',
@@ -4410,6 +4633,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             if (key.escape || (key.ctrl && input === 'c')) {
                 reviewChoiceInFlightRef.current = null;
                 setChoicePicker(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) {
@@ -4620,7 +4848,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                                 : 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' &&
+    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, agentSurface === null && permission === null ? _jsx(TaskList, { tasks: tasks }) : 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' &&
                                 conversationMutation === null &&
                                 textPrompt === null &&
@@ -4640,7 +4868,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 ||
@@ -4731,10 +4959,18 @@ function goalStatusLabel(goal) {
             return 'Goal achieved';
     }
 }
+/** 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 permissionModeDescription(mode) {
     switch (mode) {
         case 'prompt':
             return 'Ask before an undecided tool call runs';
+        case 'accept-edits':
+            return 'Approve file edits and writes without asking; shell and everything else still ask';
+        case 'plan':
+            return 'Read-only: the agent explores and presents a plan; leave plan mode to carry it out';
         case 'auto':
             return 'Approve undecided calls unless a rule or safety gate refuses';
         case 'strict':