zames_pro 2.64.1 → 2.65.1

package/dist/index.js

@@ -10,7 +10,7 @@ import { createTools } from './tools.js';
 import { createTodoStore, getTodos, setTodos, resetTodos, renderTodos, } from './extraTools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
-import { LineEditor, expandPastes, pasteReplacement, formatCompactTokens, } from './input.js';
+import { LineEditor } from './input.js';
 import { parseImagePaste, extForMime, saveToTemp, guessMime, formatSize, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, writeClipboardText, contentHash, } from './attachments.js';
 import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, } from './config.js';
 import { runConfigMenu } from './config-menu.js';
@@ -19,11 +19,13 @@ import { Transcript } from './transcript.js';
 import { UndoStore } from './undo.js';
 import { CheckpointStore, pickRecord as pickCheckpoint } from './checkpoint.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
-import { formatDiff, formatDiffStat, formatContextSources, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, resolveExtraDir, buildReviewPrompt, isDevOnlyCommand, parseBacklogItems, nextBacklogItem, buildImprovePrompt, formatDuration, formatRelativeTime, trimRestoredMessages, RESTORED_HISTORY_LIMIT, mergeMessages, hasQueuedJob, isSlashCommand, parseQueueCommand, parseLiveToggle, parseGoalCommand, isLiveConfigCommand, withGoal, formatQueueList, ctrlCEscalation, expandCommandArgs, missingCommandArgs, } from './commands.js';
+import { formatDiff, formatDiffStat, formatContextSources, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, resolveExtraDir, buildReviewPrompt, isDevOnlyCommand, parseBacklogItems, nextBacklogItem, buildImprovePrompt, formatRelativeTime, trimRestoredMessages, RESTORED_HISTORY_LIMIT, hasQueuedJob, buildSlashCommandHints, parseQueueCommand, parseLiveToggle, parseGoalCommand, isLiveConfigCommand, formatQueueList, ctrlCEscalation, expandCommandArgs, missingCommandArgs, } from './commands.js';
 import { performCompact } from './compact.js';
 import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } from './scheduler.js';
 import { renderMarkdown, setAnswerWidth } from './markdown.js';
 import { resolveAttachPath, inlineAtRefs } from './attach-refs.js';
+import { parseBacklogNote } from './backlog.js';
+import { runTask } from './run-task.js';
 import { closeWeb } from './web.js';
 import { assertCommandInsideRoot, runShell } from './shell.js';
 import { saveSession, loadLastSession, readSession, listSessions, sessionsDir, loadHistory, saveHistory, } from './sessions.js';
@@ -461,73 +463,6 @@ ${theme.dim(t('help.toggles_legend'))}
 function dirLabel(p) {
     return path.basename(p) || p;
 }
-// List of slash commands for completion when you type «/» (Tab — complete).
-// The description is localized by the help.cmd.* key at display time — see
-// buildSlashCommands().
-//
-// Dev-only commands (backlog-driven self-improvement, self-review snapshots)
-// are filtered out of the hints and rejected by the main loop unless the
-// operator is in dev mode — a regular package install must never advertise
-// them, and a muscle-memory `/improve` must not edit the user's BACKLOG.md.
-// The list itself lives in commands.ts (`isDevOnlyCommand`), one source.
-const SLASH_COMMANDS = [
-    { name: '/help', key: 'help.cmd.help' },
-    { name: '/new', key: 'help.cmd.new' },
-    { name: '/clear', key: 'help.cmd.new' },
-    { name: '/sessions', key: 'help.cmd.sessions' },
-    { name: '/chats', key: 'help.cmd.chats' },
-    { name: '/resume', key: 'help.cmd.resume' },
-    { name: '/resume-id', key: 'help.cmd.resume_id' },
-    { name: '/last', key: 'help.cmd.last' },
-    { name: '/retry', key: 'help.cmd.retry' },
-    { name: '/rename', key: 'help.cmd.rename' },
-    { name: '/context', key: 'help.cmd.context' },
-    { name: '/copy', key: 'help.cmd.copy' },
-    { name: '/chat', key: 'help.cmd.chat' },
-    { name: '/cd', key: 'help.cmd.cd' },
-    { name: '/pwd', key: 'help.cmd.pwd' },
-    { name: '/status', key: 'help.cmd.status' },
-    { name: '/reload', key: 'help.cmd.reload' },
-    { name: '/undo', key: 'help.cmd.undo' },
-    { name: '/undo-list', key: 'help.cmd.undo_list' },
-    { name: '/rewind', key: 'help.cmd.rewind' },
-    { name: '/rewind-list', key: 'help.cmd.rewind_list' },
-    { name: '/transcript', key: 'help.cmd.transcript' },
-    { name: '/diff', key: 'help.cmd.diff' },
-    { name: '/diffstat', key: 'help.cmd.diffstat' },
-    { name: '/cost', key: 'help.cmd.cost' },
-    { name: '/export', key: 'help.cmd.export' },
-    { name: '/doctor', key: 'help.cmd.doctor' },
-    { name: '/add-dir', key: 'help.cmd.add_dir' },
-    { name: '/review', key: 'help.cmd.review' },
-    { name: '/improve', key: 'help.cmd.improve' },
-    { name: '/backlog', key: 'help.cmd.backlog' },
-    { name: '/goal', key: 'help.cmd.goal' },
-    { name: '/loop', key: 'help.cmd.loop' },
-    { name: '/cron', key: 'help.cmd.cron' },
-    { name: '/jobs', key: 'help.cmd.jobs' },
-    { name: '/thinking', key: 'help.cmd.thinking' },
-    { name: '/web', key: 'help.cmd.web' },
-    { name: '/plan', key: 'help.cmd.plan' },
-    { name: '/compact', key: 'help.cmd.compact' },
-    { name: '/queue', key: 'help.cmd.queue' },
-    { name: '/tasks', key: 'help.cmd.tasks' },
-    { name: '/config', key: 'help.cmd.config' },
-    { name: '/skills', key: 'help.cmd.skills' },
-    { name: '/memory', key: 'help.cmd.memory' },
-    { name: '/remember', key: 'help.cmd.remember' },
-    { name: '/init', key: 'help.cmd.init' },
-    { name: '/mcp', key: 'help.cmd.mcp' },
-    { name: '/debug-dom', key: 'help.cmd.debug_dom' },
-    { name: '/self-review', key: 'help.self.review' },
-    { name: '/self-fix', key: 'help.self.fix' },
-    { name: '/self-done', key: 'help.self.done' },
-    { name: '/self-list', key: 'help.self.list' },
-    { name: '/self-diff', key: 'help.self.diff' },
-    { name: '/self-apply', key: 'help.self.apply' },
-    { name: '/exit', key: 'help.cmd.exit' },
-    { name: '/quit', key: 'help.cmd.exit' },
-];
 // Dynamically discovered skills and custom commands for the current workdir.
 // Filled in by refreshDynamicCommands() and shown in the «/» hint list and
 // help. Skills are surfaced as /skill-name entries (user-invokable only).
@@ -610,19 +545,11 @@ async function expandSlashTarget(workdir, name, rest) {
 }
 // Slash-command descriptions in the current language (for LineEditor hints).
 // Dev-only commands are filtered out unless the operator is in dev mode, so a
-// regular install never advertises (or accepts) them.
+// regular install never advertises (or accepts) them. The pure assembly lives
+// in commands.ts (buildSlashCommandHints); here we only supply the runtime
+// data (dev flag, translator, dynamic skills/commands).
 function buildSlashCommands() {
-    const base = SLASH_COMMANDS.filter((c) => devMode || !isDevOnlyCommand(c.name)).map((c) => ({
-        name: c.name,
-        description: t(c.key),
-    }));
-    const known = new Set(base.map((c) => c.name.toLowerCase()));
-    for (const d of dynamicCommands) {
-        if (known.has(d.name.toLowerCase()))
-            continue;
-        base.push(d);
-    }
-    return base;
+    return buildSlashCommandHints({ devMode, t, dynamic: dynamicCommands });
 }
 // We put the agent's temporary files (one-off scripts, etc.) in
 // <project>/tmp — this folder is in .gitignore and is cleaned on every launch.
@@ -634,7 +561,7 @@ async function cleanTmpDir() {
     }
     catch (e) {
         if (debug)
-            console.error('tmp: не удалось очистить:', e.message);
+            console.error('tmp: cleanup failed:', e.message);
     }
 }
 // Terminal line input with correct paste handling (Shift+Insert,
@@ -839,157 +766,6 @@ async function promptOnce(question) {
         stdin.on('data', onData);
     });
 }
-// Keyboard monitoring while the agent works.
-//
-// The terminal stays live while the agent thinks:
-//   - Esc (or Ctrl+C) — abort the current generation (a Stop click in the browser);
-//   - typing + Enter — queue a message; it goes to the agent right after
-//     the current task finishes (like "send during generation" in the
-//     DeepSeek web version).
-//
-// Input is buffered without a line editor: the typed text is shown in the
-// spinner line via onChange -> ui.setPending(). Enter sends the buffer to
-// onQueue, an empty Enter is ignored. Backspace, Ctrl+U, Esc sequences
-// (arrows/Home/End/Delete are ignored) and bracketed paste are supported.
-function watchInput({ onEscape, onChange, onQueue, } = {}) {
-    const stdin = process.stdin;
-    if (!stdin.isTTY || !stdin.setRawMode)
-        return () => { };
-    // Control characters are assembled from codes: this file must not contain
-    // "raw" ESC/CR/LF in string literals (see AGENTS.md).
-    const ESC = String.fromCharCode(27);
-    const CSI = String.fromCharCode(91);
-    const CR = String.fromCharCode(13);
-    const LF = String.fromCharCode(10);
-    const wasRaw = stdin.isRaw;
-    stdin.setRawMode(true);
-    stdin.resume();
-    process.stdout.write(ESC + '[?2004h');
-    let buf = '';
-    let inPaste = false;
-    let pasteBuf = '';
-    const pastes = [];
-    const PASTE_START = ESC + '[200~';
-    const PASTE_END = ESC + '[201~';
-    const CSI_RE = new RegExp('^' + CSI + '[0-9;]*[A-Za-z~]');
-    const emitChange = () => {
-        if (onChange)
-            onChange(buf);
-    };
-    // Pasted text: small pastes (1–2 lines) are flattened into one line;
-    // large ones (3+ lines) are collapsed into "[Pasted lines#N]" (the original
-    // text is expanded back when the message is queued).
-    const insert = (text) => {
-        buf += text
-            .split(CR + LF)
-            .join(' ')
-            .split(CR)
-            .join(' ')
-            .split(LF)
-            .join(' ');
-    };
-    const insertPaste = (raw) => {
-        const rep = pasteReplacement(raw);
-        if (!rep) {
-            insert(raw);
-            return;
-        }
-        pastes.push(rep);
-        buf += rep.marker;
-    };
-    function onData(data) {
-        let s = data.toString('utf-8');
-        // A single Esc — abort generation. Arrows come as a whole chunk and
-        // don't reach here.
-        if (!inPaste && s === ESC) {
-            if (onEscape)
-                onEscape();
-            return;
-        }
-        while (s.length) {
-            if (inPaste) {
-                const end = s.indexOf(PASTE_END);
-                if (end === -1) {
-                    pasteBuf += s;
-                    s = '';
-                }
-                else {
-                    pasteBuf += s.slice(0, end);
-                    s = s.slice(end + PASTE_END.length);
-                    inPaste = false;
-                    insertPaste(pasteBuf);
-                    pasteBuf = '';
-                }
-                emitChange();
-                continue;
-            }
-            const start = s.indexOf(PASTE_START);
-            if (start !== -1) {
-                const before = s.slice(0, start);
-                s = s.slice(start + PASTE_START.length);
-                inPaste = true;
-                pasteBuf = '';
-                if (before) {
-                    insert(before);
-                    emitChange();
-                }
-                continue;
-            }
-            const ch = s[0];
-            const code = s.charCodeAt(0);
-            s = s.slice(1);
-            if (ch === CR || ch === LF) {
-                const text = expandPastes(pastes, buf).trim();
-                buf = '';
-                pastes.length = 0;
-                emitChange();
-                if (text && onQueue)
-                    onQueue(text);
-                continue;
-            }
-            if (code === 3) {
-                // Ctrl+C — like Esc: abort generation.
-                if (onEscape)
-                    onEscape();
-                continue;
-            }
-            if (code === 21) {
-                // Ctrl+U — clear what was typed.
-                buf = '';
-                pastes.length = 0;
-                emitChange();
-                continue;
-            }
-            if (code === 127 || code === 8) {
-                // Backspace.
-                if (buf) {
-                    buf = buf.slice(0, -1);
-                    emitChange();
-                }
-                continue;
-            }
-            if (ch === ESC) {
-                // Escape sequence (arrows, Home/End, Delete) — skip.
-                const m = s.match(CSI_RE);
-                if (m)
-                    s = s.slice(m[0].length);
-                continue;
-            }
-            if (code < 32)
-                continue; // other control characters — ignore
-            buf += ch;
-            emitChange();
-        }
-    }
-    const handler = (data) => onData(data);
-    stdin.on('data', handler);
-    return () => {
-        stdin.removeListener('data', handler);
-        process.stdout.write(ESC + '[?2004l');
-        if (stdin.setRawMode)
-            stdin.setRawMode(wasRaw || false);
-    };
-}
 // ---------- workdir resolution ----------
 // The agent works in the directory it was launched from (process.cwd()).
 // This is the sandbox root: tools cannot go above it.
@@ -1084,252 +860,23 @@ async function printRestoredHistory(browser, ui, chatId = null) {
         out(theme.dim(t('chats.history_truncated', { n: String(RESTORED_HISTORY_LIMIT) })));
     }
 }
-// ---------- task runner ----------
-// Ask the operator to approve a tool call flagged by an `ask` permission rule
-// (C1). While the LineEditor owns the terminal it must be paused first, or the
-// confirmation prompt and the input line fight for the same keys. A non-TTY run
-// has no way to answer, so it DENIES (never silently allows a guarded call).
-async function askOperatorConfirm(editor, question) {
-    if (!(process.stdin.isTTY && process.stdout.isTTY))
-        return false;
-    if (editor)
-        editor.pause();
-    try {
-        const a = await promptOnce(question + ' [y/N] ');
-        return /^(y|yes|д|да)$/i.test(a.trim());
-    }
-    catch {
-        return false;
-    }
-    finally {
-        if (editor)
-            editor.resume();
-    }
-}
-async function runTask(browser, tools, taskText, workdir, opts, attachments = []) {
-    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, todosQuery = null, selfImprovement = false, } = opts;
-    // In TTY mode the UI is a LineEditor: it owns the input (queue, Esc,
-    // Ctrl+C) and draws the status ABOVE the permanent input line. In non-TTY
-    // mode (pipes) — a regular spinner + watchInput.
-    // A new task from the prompt — we reset the "stop" from the previous abort.
-    browser._stopped = false;
-    browser._abort = false;
-    const ui = editor || mod.createSpinner(currentLocale);
-    // Non-TTY parity: the ora spinner shows the same "tasks: 2/5" badge the
-    // LineEditor shows (the editor gets it via onTasksQuery in main()).
-    if (!editor && todosQuery && 'onTasksQuery' in ui) {
-        ;
-        ui.onTasksQuery = todosQuery;
-    }
-    // Mark the editor busy for the WHOLE task, not only for /init and /self-fix.
-    // Esc / Ctrl+C abort the current generation only while busy; without this a
-    // long-running tool (Bash, npm, MCP) could not be interrupted — Esc did
-    // nothing. Cleared in the finally below.
-    if (editor)
-        editor.busy = true;
-    const stopWatching = editor
-        ? () => { }
-        : watchInput({
-            onEscape: () => {
-                ui.stop();
-                console.error(theme.warn(t('msg.abort_gen_short')));
-                browser.stopGeneration().catch(() => { });
-            },
-            onChange: (text) => ui.setPending(text),
-            onQueue: (text) => {
-                queue.push({ text });
-                ui.setPending(null);
-                ui.stop();
-                console.log(theme.user(t('msg.queued', { n: queue.length })) +
-                    theme.assistant(text));
-                ui.thinking();
-            },
-        });
-    try {
-        let next = {
-            text: taskText,
-            attachments,
-            freshChat,
-            sendSystemPrompt,
-        };
-        // Execute the task, then everything the user managed to type while it
-        // ran. The queue may be replenished right during draining.
-        //
-        // NOTE: we do NOT call ui.thinking() here. runAgentLoop() fires
-        // onThinking() right before the actual browser send (after the send
-        // pause, system-prompt, etc.), so the spinner only appears when a
-        // generation really starts. Calling it here made the spinner run for
-        // the whole pre-send phase (chat creation, throttle wait) with no
-        // generation in flight.
-        while (true) {
-            // T7: per-task summary (duration + number of tool calls + tokens).
-            // Counts tools via the UI callback and reports ONE line after the task,
-            // so the operator sees how long it took and how much work happened.
-            const taskStart = Date.now();
-            // Token delta for THIS task: accumulated_token_usage is cumulative for
-            // the whole chat, so the per-task spend is after - before. Null when the
-            // counter is unknown (fresh chat / no answer yet); the token part is then
-            // omitted from the summary.
-            const tokensBefore = getTokenUsage ? getTokenUsage() : null;
-            let taskTools = 0;
-            const outcome = await mod.runAgentLoop({
-                browser,
-                tools,
-                task: withGoal(goal, next.text),
-                workdir,
-                maxIterations: maxIter,
-                freshChat: next.freshChat,
-                sendSystemPrompt: next.sendSystemPrompt,
-                attachments: next.attachments || [],
-                transcript,
-                onThinking: () => ui.thinking(),
-                onSendPause: (seconds) => ui.sendPause(seconds),
-                onSendState: (state) => {
-                    if (editor)
-                        editor.setSendState(state);
-                },
-                onNotice: (msg) => ui.warning(msg),
-                onToolCall: (name, toolArgs) => {
-                    taskTools++;
-                    ui.toolCall(name, toolArgs);
-                },
-                onToolResult: (result) => ui.toolResult(result),
-                onAssistantMessage: (msg) => {
-                    // Remember the last answer so /copy can put it on the clipboard
-                    // without re-reading the chat. Wrapped: a UI failure is swallowed
-                    // by agent-loop anyway.
-                    lastAssistantMessage = msg;
-                    opts.onAssistantFinal?.(msg);
-                    ui.assistant(msg);
-                },
-                onWarning: (msg) => ui.warning(msg),
-                onAskPermission: async (info) => {
-                    // C1: a rule with action "ask". Show the reason and wait for the
-                    // operator. In non-TTY this denies (see askOperatorConfirm).
-                    ui.warning(t('perm.ask', { tool: info.tool, reason: info.reason }));
-                    const ok = await askOperatorConfirm(editor || null, t('perm.confirm'));
-                    ui.warning(ok ? t('perm.allowed') : t('perm.denied'));
-                    transcript?.log('permission_ask', {
-                        tool: info.tool,
-                        reason: info.reason,
-                        allowed: ok,
-                    });
-                    return ok;
-                },
-                onChatReady,
-                debugLog: debug,
-                locale: currentLocale,
-                askDeadlineMs: config.browser.askDeadlineMs,
-                maxAfterToolRetries: config.browser.maxAfterToolRetries,
-                // Auto-compact between tool calls when the context nears the
-                // window limit. The callback is provided by the caller (runTask) so it
-                // can refresh the outer currentChatId. It runs in the SAME execution
-                // context (this task owns the browser send loop) and the loop awaits
-                // it, so it serializes with the throttle.
-                onAutoCompact,
-                autoCompactPct,
-                contextLimit,
-                getTokenUsage,
-                selfImprovement,
-            });
-            // The loop may end WITHOUT a model answer: an exhausted iteration
-            // limit or an ask() watchdog (the model stopped responding). In that
-            // case no assistant message was shown, and the operator saw the run
-            // just "stop" after a tool call with no explanation. Surface it.
-            if (outcome &&
-                (outcome.startsWith('Iteration limit reached') ||
-                    outcome.startsWith('ask() watchdog'))) {
-                ui.warning(outcome);
-                transcript?.log('agent_no_answer', { outcome });
-            }
-            // T7: one summary line per task (duration + tool calls + tokens spent).
-            // Printed even on an abort, so the operator sees what happened. Duration
-            // is human-readable ("45s", "1m 20s", "1h 12m 45s") with LOCALIZED unit
-            // labels, instead of a raw seconds count like "3129.2s". The token part
-            // is the DELTA of the cumulative counter for THIS task; it is omitted
-            // when the counter is unknown.
-            const tokensAfter = getTokenUsage ? getTokenUsage() : null;
-            const tokenDelta = typeof tokensBefore === 'number' && typeof tokensAfter === 'number'
-                ? Math.max(0, tokensAfter - tokensBefore)
-                : null;
-            const summaryParts = [
-                t('task_sum.dur', {
-                    dur: formatDuration(Date.now() - taskStart, {
-                        h: t('dur.h'),
-                        m: t('dur.m'),
-                        s: t('dur.s'),
-                    }),
-                }),
-                t('task_sum.tools', { n: String(taskTools) }),
-            ];
-            if (tokenDelta !== null) {
-                summaryParts.push(t('task_sum.tokens', { n: formatCompactTokens(tokenDelta) }));
-            }
-            const summary = theme.taskSummary('· ' + summaryParts.join(' · '));
-            if (editor)
-                editor.printAbove(summary);
-            else
-                console.log(summary);
-            // Aborted (Esc/Ctrl+C) — we don't start the next tasks from the queue
-            // and clear it, so "stop" really stops everything.
-            if (browser._stopped) {
-                queue.length = 0;
-                break;
-            }
-            if (!queue.length)
-                break;
-            // Merge the LEADING plain-text messages into ONE batch (fewer sends ->
-            // less rate-limit risk and the operator's thoughts arrive together). We
-            // stop at the first slash-command: it must NOT be sent as a task — it is
-            // handled by the main loop, so we leave it (and anything after it) in
-            // the queue and break out of this task's drain loop.
-            let batchLen = 0;
-            while (batchLen < queue.length && !isSlashCommand(queue[batchLen].text)) {
-                batchLen++;
-            }
-            if (batchLen === 0)
-                break;
-            const batch = queue.splice(0, batchLen);
-            const merged = mergeMessages(batch);
-            if (!merged.text.trim())
-                break;
-            ui.stop();
-            const banner = batch.length === 1
-                ? theme.user(t('msg.from_queue')) + theme.assistant(batch[0].text)
-                : theme.user(t('msg.from_queue_batch', { n: batch.length })) +
-                    theme.assistant(t('msg.batch_joined', { n: batch.length }));
-            if (editor)
-                editor.printAbove(banner);
-            else
-                console.log(banner);
-            transcript?.log('queued_task', { task: merged.text, count: batch.length });
-            next = {
-                text: merged.text,
-                attachments: merged.attachments,
-                freshChat: false,
-                sendSystemPrompt: false,
-            };
-        }
-    }
-    catch (e) {
-        ui.stop();
-        console.error(theme.error(String.fromCharCode(10) + t('msg.agent_error')), e.message);
-        if (debug)
-            console.error(e.stack);
-        transcript?.log('agent_error', { error: e.message });
-    }
-    finally {
-        stopWatching();
-        ui.stop();
-        if (editor)
-            editor.busy = false;
-        // Detach the send hooks so a later browser.ask() outside this task cannot
-        // start a stale spinner.
-        browser.onSendStart = null;
-        browser.onSendPause = null;
-        browser.onSendState = null;
-        browser.onNotice = null;
-    }
+// Build the explicit dependency bag for runTask() (src/run-task.ts). The
+// main loop owns the browser/queue/config state, so every call site passes
+// the SAME collaborators here instead of runTask reaching into module
+// globals.
+function runTaskDeps() {
+    return {
+        t,
+        locale: currentLocale,
+        debug,
+        maxIter,
+        config,
+        runAgentLoop: mod.runAgentLoop,
+        createSpinner: mod.createSpinner,
+        onAssistantMessage: (msg) => {
+            lastAssistantMessage = msg;
+        },
+    };
 }
 // ---------- main ----------
 async function main() {
@@ -1464,7 +1011,7 @@ async function main() {
             }
         }
         await autoReload();
-        await runTask(browser, tools, task, currentWorkdir, {
+        await runTask(runTaskDeps(), browser, tools, task, currentWorkdir, {
             transcript,
             freshChat,
             sendSystemPrompt,
@@ -1974,6 +1521,11 @@ async function main() {
         if (path === 'ui.locale' && isLocale(value)) {
             currentLocale = value;
             config.ui.locale = value;
+            // The browser (and its startup spinner) are created ONCE, so their own
+            // notices must be told about the new language explicitly — otherwise a
+            // DeepSeek-side message printed later would still come out in the OLD
+            // language until a restart.
+            browser.setLocale(value);
             if (editor) {
                 editor.setLocale(value);
                 editor.setCommands(buildSlashCommands());
@@ -3255,7 +2807,7 @@ async function main() {
             if (editor)
                 editor.busy = true;
             try {
-                await runTask(browser, tools, lastTaskText, currentWorkdir, {
+                await runTask(runTaskDeps(), browser, tools, lastTaskText, currentWorkdir, {
                     transcript,
                     freshChat: false,
                     sendSystemPrompt: false,
@@ -3465,7 +3017,7 @@ async function main() {
             if (editor)
                 editor.busy = true;
             try {
-                await runTask(browser, improveTools, buildImprovePrompt(item), currentWorkdir, {
+                await runTask(runTaskDeps(), browser, improveTools, buildImprovePrompt(item), currentWorkdir, {
                     transcript,
                     freshChat: false,
                     sendSystemPrompt: false,
@@ -3531,25 +3083,9 @@ async function main() {
             }
             // Deterministic append: no model round-trip is needed to record a
             // one-line note, and a pure helper cannot invent a different id than
-            // the one the operator is shown. An optional leading `P0..P3` sets the
-            // priority; the first line is the title, the rest becomes the body.
-            let priority = 'P2';
-            let body = note;
-            for (const p of ['P0', 'P1', 'P2', 'P3']) {
-                if (note.toUpperCase().startsWith(p + ' ')) {
-                    priority = p;
-                    body = note.slice(p.length + 1);
-                    break;
-                }
-            }
-            const bodyLines = body.split(String.fromCharCode(10));
-            const title = bodyLines[0];
-            const rest = bodyLines.slice(1).join(String.fromCharCode(10)).trim();
-            const res = mod.appendBacklogItem(backlogText, {
-                title,
-                priority,
-                note: rest || undefined,
-            });
+            // the one the operator is shown.
+            const parsed = parseBacklogNote(note);
+            const res = mod.appendBacklogItem(backlogText, parsed);
             await fs.writeFile(backlogFile, res.text, 'utf-8');
             console.log(theme.system(t('backlog.adding', { v: res.id })));
             continue;
@@ -3566,7 +3102,7 @@ async function main() {
             if (editor)
                 editor.busy = true;
             try {
-                await runTask(browser, reviewTools, reviewTask, currentWorkdir, {
+                await runTask(runTaskDeps(), browser, reviewTools, reviewTask, currentWorkdir, {
                     transcript,
                     freshChat: false,
                     sendSystemPrompt: false,
@@ -3821,7 +3357,7 @@ async function main() {
         if (editor)
             editor.busy = true;
         try {
-            await runTask(browser, tools, finalTaskText, currentWorkdir, {
+            await runTask(runTaskDeps(), browser, tools, finalTaskText, currentWorkdir, {
                 transcript,
                 freshChat: freshChatNext,
                 sendSystemPrompt: sendSystemPromptNext,