@namzu/cli 28.0.0 → 28.1.0

package/dist/tui/App.js

@@ -50,7 +50,10 @@ 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 { isRepeatedNotice } from './notices.js';
+import { checklistProgress } from './Checklist.js';
+import { TaskList, taskListRows } from './TaskList.js';
+import { applyTaskOperation, isTaskTool, removeTask, taskOperationFor, taskReportChecklist, upsertTask, } from './task-activity.js';
 import { TextPrompt } from './TextPrompt.js';
 import { modelCatalogueView } from './model-catalogue-view.js';
 import { conversationEvidenceView } from './conversation-evidence-view.js';
@@ -64,7 +67,7 @@ import { assistantTranscriptTexts } from './conversation-history.js';
 import { copyTargetsForResponse } from './copy-targets.js';
 import { editablePrompts } from './edit-prompts.js';
 import { editDraftInExternalEditor } from './external-editor.js';
-import { liveWindow } from './live-window.js';
+import { checklistInView, liveWindow } from './live-window.js';
 import { resolveModelSwitch, } from './model-switch.js';
 import { parseModelSelectionIntent, resolveModelSelectionIntent } from './model-selection-intent.js';
 import { describeCodexDeviceLoginStart, describeLoginOutcome, describeLoginStart, describeLogout, describeProviderLogout, } from './login-prompt.js';
@@ -478,8 +481,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * 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());
+    /**
+     * The same list, current NOW. React runs state updaters lazily, and each
+     * task event needs the task's previous state to say what changed and the
+     * whole list to draw the block it leaves in the transcript.
+     */
+    const tasksRef = useRef([]);
     // Bumped to reset the <Static> transcript log (on /clear, /clear-screen and /resume).
     const [resetKey, setResetKey] = useState(0);
     /**
@@ -1094,35 +1101,41 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     }, []);
     const pushMessage = useCallback((role, content, pending = false, glyph, detail, glyphColor, meta, activity) => {
         const id = nextId();
-        setMessages((prev) => [
-            ...prev,
-            {
-                id,
-                role,
-                content,
-                pending,
-                glyph,
-                detail,
-                glyphColor,
-                meta,
-                activity,
-                // Numbered only if this body will actually be COLLAPSED — the
-                // number exists to be read off a hint, and a body that fits
-                // prints no hint. Numbering every body instead would leave gaps
-                // the operator can see nothing of, make bare `/expand` reprint a
-                // two-line body while the truncated one above it stayed hidden,
-                // and let the out-of-range message quote a count that includes
-                // blocks no hint ever named.
-                //
-                // Derived from `prev` rather than a counter, so the number is a
-                // fact about the transcript rather than a second record of it.
-                ...((activity && detail?.length) || willCollapse(detail)
-                    ? {
-                        detailRef: prev.filter((m) => m.detailRef !== undefined).length + 1,
-                    }
-                    : {}),
-            },
-        ]);
+        const candidate = { role, content, pending, glyph, detail, activity };
+        setMessages((prev) => 
+        // The notice layer, not each caller, keeps a notice from printing
+        // twice in a row: the same sentence twice reads as two events.
+        isRepeatedNotice(prev.at(-1), candidate)
+            ? prev
+            : [
+                ...prev,
+                {
+                    id,
+                    role,
+                    content,
+                    pending,
+                    glyph,
+                    detail,
+                    glyphColor,
+                    meta,
+                    activity,
+                    // Numbered only if this body will actually be COLLAPSED — the
+                    // number exists to be read off a hint, and a body that fits
+                    // prints no hint. Numbering every body instead would leave gaps
+                    // the operator can see nothing of, make bare `/expand` reprint a
+                    // two-line body while the truncated one above it stayed hidden,
+                    // and let the out-of-range message quote a count that includes
+                    // blocks no hint ever named.
+                    //
+                    // Derived from `prev` rather than a counter, so the number is a
+                    // fact about the transcript rather than a second record of it.
+                    ...((activity && detail?.length) || willCollapse(detail)
+                        ? {
+                            detailRef: prev.filter((m) => m.detailRef !== undefined).length + 1,
+                        }
+                        : {}),
+                },
+            ]);
         return id;
     }, [nextId]);
     /**
@@ -1272,30 +1285,42 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             }
         }
     }, [subagents, pushMessage, session]);
-    const applyPermissionMode = useCallback((mode) => {
+    /**
+     * Change the permission mode, now — including while a turn runs.
+     *
+     * It used to be refused until the current work settled. The reference
+     * terminal applies the key at once, mid-turn, and so does this: the running
+     * turn reads the mode at every decision (`SendOptions.currentPermissionMode`),
+     * so the change governs its next tool call and every turn after. A dialog
+     * already on screen is decided under the mode it was asked under; entering
+     * plan refuses the next change the turn attempts; leaving plan re-runs
+     * nothing it refused. The change is recorded on the running turn's log as
+     * `approval_policy_changed`, which also tells the model once.
+     *
+     * `announce` is for a change asked for by name (`/permissions`), which gets
+     * a reply. Shift+Tab is a reflex key: the footer is its reply, as it is in
+     * the reference, and five presses no longer leave five transcript lines.
+     */
+    const applyPermissionMode = useCallback((mode, announce = true) => {
         if (!session?.hasProvider) {
             pushMessage('system', 'Choose a model before changing permissions.');
             return;
         }
-        if (state !== 'idle' ||
-            abortRef.current !== null ||
-            hasUnsettledTurn() ||
-            queuedRef.current.length > 0 ||
-            permissionResolveRef.current !== null ||
-            compactingRef.current) {
-            pushMessage('system', 'Permissions were not changed. Finish or stop the current work first.');
-            return;
-        }
         if (!session.resetApprovalLatch) {
             pushMessage('system', 'This session cannot reset approvals. Reconnect before changing permissions.');
             return;
         }
         session.resetApprovalLatch();
+        // The ref first: a running turn reads it at its next decision, and the
+        // record below makes the change durable before that decision is made.
         permissionModeRef.current = mode;
         permissionModeSourceRef.current = 'session';
         setPermissionModeState(mode);
-        pushMessage('system', `Permissions: ${permissionModeLabel(mode)} for this session. ${permissionModeDescription(mode)}`);
-    }, [hasUnsettledTurn, pushMessage, session, state]);
+        void session.setPermissionMode?.(mode);
+        if (announce) {
+            pushMessage('system', `Permissions: ${permissionModeLabel(mode)} for this session. ${permissionModeDescription(mode)}`);
+        }
+    }, [pushMessage, session]);
     const applyReasoningEffort = useCallback((effort, selectedSession) => {
         if (!session?.hasProvider) {
             pushMessage('system', 'No active session — pick a provider before changing reasoning effort.');
@@ -1546,14 +1571,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * 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.
+     * reflex should fall. The change goes through the same path `/permissions`
+     * uses and takes effect at once, mid-turn included; the footer is its only
+     * on-screen reply (see `applyPermissionMode`).
      */
     const cyclePermissionMode = useCallback(() => {
         const current = permissionModeRef.current;
         const next = current === 'prompt' ? 'accept-edits' : current === 'accept-edits' ? 'plan' : 'prompt';
-        applyPermissionMode(next);
+        applyPermissionMode(next, false);
     }, [applyPermissionMode]);
     const runConversationExport = useCallback((destination) => {
         const source = stableExportSource();
@@ -2604,10 +2629,23 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     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;
+    // The current-step row stands in for a checklist that is out of view. While
+    // the newest checklist block, everything printed after it and the live
+    // furniture fit the screen, the block is on screen, and the row would only
+    // say one of its lines again. Once later rows push the block's head off a
+    // short screen, the row is what keeps the current step visible.
+    const checklistShown = checklistInView({
+        messages,
+        rows: terminal.rows,
+        columns: terminal.columns,
+        furnitureRows: LIVE_FURNITURE_ROWS + fullToolFurniture,
+        raw: rawOutput,
+    });
+    const liveTasks = checklistShown ? [] : tasks;
+    const fullTaskFurniture = taskListRows(liveTasks);
     const compactWork = LIVE_FURNITURE_ROWS + fullTaskFurniture + fullToolFurniture >= terminal.rows;
-    const taskFurniture = compactWork && fullTaskFurniture > 0 ? 2 : fullTaskFurniture;
+    const taskFurniture = 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
@@ -3516,6 +3554,24 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         });
         sendTerminalNotification({ kind: 'approval-required' });
     }), [sendTerminalNotification, setChoicePicker, setSelectedChoice]);
+    /**
+     * Grow this turn's open task block, or open one. The whole plan rides along
+     * so the block shows the checklist as it stood after the operation; a
+     * `null` operation (a `task_list`) refreshes it without naming a change.
+     */
+    const writeTaskBlock = useCallback((st, operation, checklist) => {
+        st.taskBlockKey ??= nextId();
+        const key = st.taskBlockKey;
+        const id = nextId();
+        setMessages((prev) => applyTaskOperation(prev, {
+            key,
+            id,
+            operation,
+            checklist,
+            settled: settledRef.current,
+            glyphColor: theme.status.ok,
+        }));
+    }, [nextId]);
     // 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
@@ -3700,6 +3756,28 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
                     break;
                 }
+                if (isTaskTool(event.toolName)) {
+                    // The task event already wrote the block. A listing refreshes it
+                    // while there is a plan to show; with none it keeps its own row.
+                    if (!event.isError && event.toolName !== 'task_list') {
+                        setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
+                        break;
+                    }
+                    if (!event.isError && tasksRef.current.length > 0) {
+                        writeTaskBlock(st, null, tasksRef.current);
+                        setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
+                        break;
+                    }
+                    // Its own row, in words: the call's label, and the result's
+                    // label rather than the model's receipt, which names ids.
+                    pushMessage('tool', done?.label ?? formatToolCall(event.toolName, event.summary, true), false, event.isError ? '✗' : '✓', undefined, event.isError ? theme.status.error : theme.status.ok);
+                    const said = event.resultLabel ?? (event.isError ? 'the task tool refused the call' : '');
+                    if (said.length > 0) {
+                        pushMessage('tool', event.isError ? `failed: ${said}` : said, false, '⎿');
+                    }
+                    setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
+                    break;
+                }
                 const catalogue = !event.isError && event.toolName === 'agent_models' && event.output !== undefined
                     ? modelCatalogueView(event.output) : undefined;
                 if (catalogue !== undefined) {
@@ -3758,31 +3836,34 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 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);
+                // The transcript owns the checklist: consecutive operations fold
+                // into one block there (task-activity.ts). The live row above the
+                // composer only names the current step.
                 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, '☒');
+                // A reply in progress ends here, as it does at a tool call, so
+                // the block lands after the text that led to it.
+                closeAssistant();
+                let operation;
+                if (event.removed) {
+                    // Removed from the plan: it leaves the checklist, and the block
+                    // says so, rather than drawing it as still open.
+                    const next = removeTask(tasksRef.current, item.id, item.subject);
+                    operation = next.operation;
+                    tasksRef.current = next.tasks;
                 }
-                else if (isNew) {
-                    pushMessage('tool', event.subject, false, '☐');
+                else {
+                    const previous = tasksRef.current.find((task) => task.id === item.id);
+                    operation = taskOperationFor(previous, item);
+                    tasksRef.current = upsertTask(tasksRef.current, item);
                 }
+                const checklist = tasksRef.current;
+                setTasks(checklist);
+                if (operation)
+                    writeTaskBlock(st, operation, checklist);
                 break;
             }
             case 'job':
@@ -3852,7 +3933,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 st.outcome = 'stopped';
                 st.queuePauseOutcome = 'paused';
                 st.notification = { kind: 'turn-settled', outcome: 'stopped' };
-                pushMessage('system', describeTurnInterruption(event), false, '⏸');
+                pushMessage('system', describeTurnInterruption(event), false, '‖');
                 break;
             case 'error':
                 closeAssistant();
@@ -3865,7 +3946,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     st.notification = null;
                 break;
         }
-    }, [appendToMessage, finalizeMessage, flushStream, pushMessage]);
+    }, [appendToMessage, finalizeMessage, flushStream, pushMessage, writeTaskBlock]);
     applyEventRef.current = applyEvent;
     const runTurn = useCallback(async (prompt) => {
         // A passive queue effect can still hold the previous render's session
@@ -3975,7 +4056,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // 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();
+        tasksRef.current = [];
         // The model interleaves text → tool → text across iterations; `applyEvent`
         // renders each one in order.
         const st = {
@@ -4201,6 +4282,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     // prompt closes it. A paused turn is never closed this way.
                     abandonInterrupted: true,
                     permissionMode: turnPermissionMode,
+                    // Read at every decision: the operator may change the mode
+                    // while this turn runs, and the change governs what follows.
+                    currentPermissionMode: () => permissionModeRef.current,
                     limits: turnLimits,
                     ...(turnReasoningEffort !== undefined ? { effort: turnReasoningEffort } : {}),
                     ...(turnOrchestrateMode ? { orchestrate: true } : {}),
@@ -5254,6 +5338,24 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             // painted as state of the one now on screen.
                             if (conversationGenRef.current !== generation)
                                 return;
+                            const checklist = slash.name === 'tasks' && outcome?.kind === 'report'
+                                ? taskReportChecklist(outcome.rows)
+                                : undefined;
+                            if (checklist) {
+                                // Drawn by the same checklist as the transcript's task
+                                // blocks: the same marks, and no id or owner column.
+                                const id = nextId();
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        id,
+                                        role: 'system',
+                                        content: checklist.length === 0 ? 'No tasks yet.' : checklistProgress(checklist),
+                                        ...(checklist.length > 0 ? { checklist } : {}),
+                                    },
+                                ]);
+                                return;
+                            }
                             pushMessage('system', outcome
                                 ? renderOutcome(outcome)
                                 : `/${slash.name} is registered but this session cannot run it.`);
@@ -6490,7 +6592,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     // where it is decided rather than guessed on the screen: with no
                     // session behind the picker, esc exits namzu and the footer says
                     // so instead of offering a cancel nobody will see.
-                    cancelExits: !session?.hasProvider })) : (_jsxs(_Fragment, { children: [agentSurface === null && outputViewer === null ? (_jsx(LiveActivity, { compact: compactWork, activeTools: visibleActiveTools, working: state === 'thinking' || state === 'tool', interruptible: abortRef.current !== null, animate: stdout.isTTY === true && permission === null && textPrompt === null, thinking: thinking })) : null, agentSurface === null && outputViewer === 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, queuedCount: queuedPermissionCount, sourceLabel: permissionSourceLabel, columns: terminal.columns, rows: terminal.rows })) : null, textPrompt ? (_jsx(TextPrompt, { columns: Math.max(1, (terminal.columns ?? 80) - 2), title: textPrompt.title, placeholder: textPrompt.placeholder, initialValue: textPrompt.initialValue, emptyNotice: textPrompt.emptyNotice, hidden: permission !== null || (agentSurface !== null || outputViewer !== null), onSubmit: submitTextPrompt, onCancel: cancelTextPrompt }, textPrompt.token)) : permission === null && agentSurface === null && outputViewer === null && choicePicker ? (_jsx(ChoicePicker, { busy: 'busy' in choicePicker && choicePicker.busy === true, 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 && outputViewer === null && copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { working: state === 'thinking' || state === 'tool' || visibleActiveTools.length > 0, focus: phase === 'ready' &&
+                    cancelExits: !session?.hasProvider })) : (_jsxs(_Fragment, { children: [agentSurface === null && outputViewer === null ? (_jsx(LiveActivity, { compact: compactWork, activeTools: visibleActiveTools, working: state === 'thinking' || state === 'tool', interruptible: abortRef.current !== null, animate: stdout.isTTY === true && permission === null && textPrompt === null, thinking: thinking })) : null, agentSurface === null && outputViewer === null && permission === null ? (_jsx(TaskList, { tasks: liveTasks })) : null, permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls, review: permission.review, summary: permission.summary, detailsOpen: permissionDetailsOpen, reviewOffset: permissionReviewOffset, choice: permissionChoice, queuedCount: queuedPermissionCount, sourceLabel: permissionSourceLabel, columns: terminal.columns, rows: terminal.rows })) : null, textPrompt ? (_jsx(TextPrompt, { columns: Math.max(1, (terminal.columns ?? 80) - 2), title: textPrompt.title, placeholder: textPrompt.placeholder, initialValue: textPrompt.initialValue, emptyNotice: textPrompt.emptyNotice, hidden: permission !== null || (agentSurface !== null || outputViewer !== null), onSubmit: submitTextPrompt, onCancel: cancelTextPrompt }, textPrompt.token)) : permission === null && agentSurface === null && outputViewer === null && choicePicker ? (_jsx(ChoicePicker, { busy: 'busy' in choicePicker && choicePicker.busy === true, 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 && outputViewer === 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 &&
@@ -6512,7 +6614,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                     textPrompt === null &&
                                     choicePicker === null &&
                                     copyPicker === null &&
-                                    agentSurface === null && outputViewer === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: [queuePause ? '⏸' : '⏎', " ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014", ' ', queuePause
+                                    agentSurface === null && outputViewer === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: [queuePause ? '‖' : '⏎', " ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014", ' ', queuePause
                                                 ? queuePause.outcome === 'paused'
                                                     ? 'held after a resumable turn 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`