zames_pro 2.54.0 → 2.58.0

package/dist/index.js

@@ -11,21 +11,26 @@ import { createTodoStore, getTodos, setTodos, resetTodos, renderTodos, } from '.
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
 import { LineEditor, expandPastes, pasteReplacement, formatCompactTokens, } from './input.js';
-import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, contentHash, } from './attachments.js';
+import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, 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';
 import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n.js';
 import { Transcript } from './transcript.js';
 import { UndoStore } from './undo.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
-import { formatDiff, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, renderPermissions, resolveExtraDir, buildReviewPrompt, formatDuration, formatRelativeTime, trimRestoredMessages, RESTORED_HISTORY_LIMIT, mergeMessages, hasQueuedJob, isSlashCommand, parseQueueCommand, parseLiveToggle, parseGoalCommand, isLiveConfigCommand, withGoal, formatQueueList, ctrlCEscalation, } from './commands.js';
+import { formatDiff, formatDiffStat, formatContextSources, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, resolveExtraDir, buildReviewPrompt, formatDuration, formatRelativeTime, trimRestoredMessages, RESTORED_HISTORY_LIMIT, mergeMessages, hasQueuedJob, isSlashCommand, parseQueueCommand, parseLiveToggle, parseGoalCommand, isLiveConfigCommand, withGoal, formatQueueList, ctrlCEscalation, } from './commands.js';
 import { performCompact } from './compact.js';
 import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } from './scheduler.js';
 import { renderMarkdown, setAnswerWidth } from './markdown.js';
 import { closeWeb } from './web.js';
+import { assertCommandInsideRoot, runShell } from './shell.js';
 import { saveSession, loadLastSession, readSession, listSessions, sessionsDir, loadHistory, saveHistory, } from './sessions.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const NL = String.fromCharCode(10);
+// The last final assistant message, for the /copy command. Module-level
+// because runTask() (which sees the answers) and the main loop (which handles
+// /copy) are separate functions.
+let lastAssistantMessage = '';
 // Floor for a /loop interval. A loop faster than the send throttle (15s)
 // cannot do anything useful and would just hammer the rate limit, so we refuse
 // it. It does NOT touch the throttle itself.
@@ -53,7 +58,7 @@ function getPositional() {
     const positional = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if (['--dir', '--task', '--max-iter', '--project', '--chat'].includes(a)) {
+        if (['--dir', '--task', '--max-iter', '--chat', '--output-format'].includes(a)) {
             i++;
             continue;
         }
@@ -87,7 +92,6 @@ const headless = hasFlag('--headed')
     ? false
     : hasFlag('--headless') || config.headless;
 const debug = hasFlag('--debug') || config.debug;
-const calibrate = hasFlag('--calibrate');
 const maxIterArg = getArg('--max-iter', null);
 const maxIter = maxIterArg !== null ? Number(maxIterArg) : config.maxIterations;
 const positional = getPositional();
@@ -102,6 +106,23 @@ const resendPrompt = hasFlag('--resend-prompt');
 // --new-chat: kept for compatibility — this is the default behavior anyway.
 const newChatFlag = hasFlag('--new-chat');
 const resumeLastFlag = hasFlag('--resume-last');
+// Plan mode (read-only): start with it ON via --plan, toggle with /plan. When
+// on, mutating tools are filtered out of the tool set entirely (see
+// filterToolsForReadOnly). Declared here because tool creation happens before
+// the main loop.
+let planMode = hasFlag('--plan');
+// Machine-readable output for scripts/CI. 'text' (default) is the normal
+// human UI; 'json'/'jsonl' stream the transcript events as JSON lines on
+// stdout, while all human text is pushed to stderr so the stream stays clean.
+// Meant for one-shot mode (--task).
+const outputFormat = (getArg('--output-format', 'text') || 'text').toLowerCase();
+const jsonMode = outputFormat === 'json' || outputFormat === 'jsonl';
+if (jsonMode) {
+    // Keep stdout for the event stream only.
+    console.log = ((...a) => {
+        console.error(...a);
+    });
+}
 // ---------- session persistence ----------
 // We store sessions (DeepSeek chats) in ~/.zames/.sessions so they survive
 // a restart and are available for explicit restore (--resume-last,
@@ -167,10 +188,10 @@ const RELOADABLE = [
     'self-review',
     'diff',
     'undo',
-    'confirm',
     'transcript',
     'spinner',
     'config',
+    'fsutil',
 ];
 const mod = {
     createTools,
@@ -289,8 +310,9 @@ ${theme.bold(t('help.options'))}
   --max-iter <n>     ${t('help.opt.max_iter', { n: config.maxIterations })}
   --headless         ${t('help.opt.headless')}
   --headed           ${t('help.opt.headed')}
+  --plan             ${t('help.opt.plan')}
+  --output-format <f> ${t('help.opt.output_format')}
   --debug            ${t('help.opt.debug')}
-  --calibrate        ${t('help.opt.calibrate')}
   --dev              ${t('help.opt.dev')}
   --no-color         ${t('help.opt.no_color')}
   --version, -v      ${t('help.opt.version')}
@@ -309,40 +331,63 @@ ${theme.bold(t('help.while_working'))}
   ${t('help.key.backslash')}
   ${t('help.key.attach')}
   ${t('help.key.esc')}
+  ${t('help.key.bang')}
 
 ${theme.bold(t('help.commands'))}
+
+${theme.bold(t('help.sec.session'))}
   ${t('help.cmd.new')}
   ${t('help.cmd.sessions')}
-  ${t('help.cmd.resume_id')}
   ${t('help.cmd.chats')}
   ${t('help.cmd.resume')}
+  ${t('help.cmd.resume_id')}
   ${t('help.cmd.last')}
+  ${t('help.cmd.retry')}
+  ${t('help.cmd.rename')}
+
+${theme.bold(t('help.sec.workspace'))}
   ${t('help.cmd.chat')}
   ${t('help.cmd.cd')}
   ${t('help.cmd.pwd')}
   ${t('help.cmd.status')}
   ${t('help.cmd.reload')}
-  ${t('help.cmd.undo')}
-  ${t('help.cmd.undo_list')}
-  ${t('help.cmd.transcript')}
+
+${theme.bold(t('help.sec.git'))}
   ${t('help.cmd.diff')}
-  ${t('help.cmd.cost')}
-  ${t('help.cmd.export')}
-  ${t('help.cmd.doctor')}
-  ${t('help.cmd.permissions')}
-  ${t('help.cmd.add_dir')}
-  ${t('help.cmd.review')}
+  ${t('help.cmd.diffstat')}
+
+${theme.bold(t('help.sec.agent'))}
   ${t('help.cmd.goal')}
   ${t('help.cmd.loop')}
   ${t('help.cmd.cron')}
   ${t('help.cmd.jobs')}
   ${t('help.cmd.thinking')}
   ${t('help.cmd.web')}
+  ${t('help.cmd.plan')}
   ${t('help.cmd.compact')}
   ${t('help.cmd.queue')}
   ${t('help.cmd.tasks')}
+
+${theme.bold(t('help.sec.context'))}
+  ${t('help.cmd.context')}
+  ${t('help.cmd.skills')}
+  ${t('help.cmd.memory')}
+  ${t('help.cmd.remember')}
+  ${t('help.cmd.init')}
+  ${t('help.cmd.mcp')}
   ${t('help.cmd.config')}
   ${t('help.cmd.lang')}
+
+${theme.bold(t('help.sec.files'))}
+  ${t('help.cmd.transcript')}
+  ${t('help.cmd.undo')}
+  ${t('help.cmd.undo_list')}
+  ${t('help.cmd.export')}
+  ${t('help.cmd.cost')}
+  ${t('help.cmd.copy')}
+  ${t('help.cmd.doctor')}
+  ${t('help.cmd.add_dir')}
+  ${t('help.cmd.review')}
   ${t('help.cmd.debug_dom')}
   ${t('help.cmd.help')}
   ${t('help.cmd.exit')}
@@ -384,6 +429,10 @@ const SLASH_COMMANDS = [
     { 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' },
@@ -393,10 +442,10 @@ const SLASH_COMMANDS = [
     { name: '/undo-list', key: 'help.cmd.undo_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: '/permissions', key: 'help.cmd.permissions' },
     { name: '/add-dir', key: 'help.cmd.add_dir' },
     { name: '/review', key: 'help.cmd.review' },
     { name: '/goal', key: 'help.cmd.goal' },
@@ -405,12 +454,14 @@ const SLASH_COMMANDS = [
     { 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' },
@@ -1003,7 +1054,7 @@ async function printRestoredHistory(browser, ui, chatId = null) {
 }
 // ---------- task runner ----------
 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, } = opts;
+    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, todosQuery = null, } = 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.
@@ -1011,6 +1062,12 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
     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
@@ -1084,7 +1141,14 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                     ui.toolCall(name, toolArgs);
                 },
                 onToolResult: (result) => ui.toolResult(result),
-                onAssistantMessage: (msg) => ui.assistant(msg),
+                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),
                 onChatReady,
                 debugLog: debug,
@@ -1216,9 +1280,6 @@ async function main() {
         printHelp();
         return;
     }
-    if (calibrate) {
-        console.log(theme.warn(t('calibrate')));
-    }
     await cleanTmpDir();
     let currentWorkdir;
     let sandboxRoot;
@@ -1237,6 +1298,9 @@ async function main() {
         dir: config.transcript.dir,
         enabled: config.transcript.enabled,
         sessionName: dirLabel(currentWorkdir),
+        // In json/jsonl mode mirror every event to stdout as a JSON line, even
+        // when the transcript FILE is disabled.
+        onLine: jsonMode ? (line) => process.stdout.write(line) : null,
     });
     if (transcript.file) {
         console.log(theme.system(t('msg.transcript', { v: transcript.file })));
@@ -1258,6 +1322,8 @@ async function main() {
             if (srv.error)
                 console.error(theme.warn(t('mcp.server_error', { name: srv.name, error: srv.error })));
         }
+        for (const w of st.warnings)
+            console.error(theme.warn(w));
     }
     catch (e) {
         console.error(theme.warn(t('mcp.load_failed', { v: e.message })));
@@ -1298,7 +1364,10 @@ async function main() {
     }
     // One-shot mode
     if (task) {
-        const tools = mod.createTools(currentWorkdir, { undo });
+        const tools = mod.createTools(currentWorkdir, {
+            undo,
+            readOnly: planMode,
+        });
         if (mcpPool)
             tools.push(...mcpPool.tools);
         let freshChat = true;
@@ -1361,6 +1430,8 @@ async function main() {
     const promptOnResume = () => resendPrompt || config.browser.resendPromptOnResume === true;
     let lastChats = [];
     let currentChatId = null;
+    // The last task the operator sent (used by /retry). Plain text only.
+    let lastTaskText = '';
     let running = true;
     // The agent's TodoWrite checklist, shared with the tool factory and
     // persisted in the session JSON. A store (not module state) so /reload does
@@ -2153,6 +2224,36 @@ async function main() {
         const lower = trimmed.toLowerCase();
         if (['/exit', '/quit', 'exit', 'quit'].includes(lower))
             break;
+        // `!command` — run a shell command directly, without asking the model
+        // (like Claude Code's bash mode). The same sandbox guard as the Bash tool
+        // applies, so a direct command cannot leave the project either.
+        if (trimmed.startsWith('!')) {
+            const cmd = trimmed.slice(1).trim();
+            if (!cmd) {
+                console.error(theme.warn(t('shell.empty')));
+                continue;
+            }
+            try {
+                assertCommandInsideRoot(currentWorkdir, cmd);
+            }
+            catch (e) {
+                console.error(theme.error(e.message));
+                continue;
+            }
+            transcript.log('shell_command', { command: cmd });
+            if (editor)
+                editor.lock(t('shell.running'));
+            try {
+                const out = await runShell(currentWorkdir, cmd);
+                console.log(theme.system(out));
+                transcript.log('shell_result', { command: cmd, result: out });
+            }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
+            continue;
+        }
         if (lower === '/help' ||
             lower === 'help' ||
             lower.startsWith('/help ') ||
@@ -2711,6 +2812,28 @@ async function main() {
                 continue;
             }
         }
+        if (lower === '/plan' || lower.startsWith('/plan ')) {
+            const arg = trimmed.slice('/plan'.length).trim().toLowerCase();
+            if (arg === '' || arg === 'toggle')
+                planMode = !planMode;
+            else if (arg === 'on' || arg === '1' || arg === 'true' || arg === 'вкл')
+                planMode = true;
+            else if (arg === 'off' ||
+                arg === '0' ||
+                arg === 'false' ||
+                arg === 'выкл')
+                planMode = false;
+            else {
+                console.error(theme.warn(t('msg.unknown_cmd', { v: trimmed })));
+                continue;
+            }
+            const line = t(planMode ? 'plan.on' : 'plan.off');
+            if (editor)
+                editor.printAbove(theme.system(line));
+            else
+                console.log(theme.system(line));
+            continue;
+        }
         if (lower === '/mcp') {
             if (!mcpPool) {
                 console.log(theme.dim(t('mcp.none')));
@@ -2733,6 +2856,8 @@ async function main() {
                         theme.dim('(' + String(srv.tools.length) + ')'));
                 }
             }
+            for (const w of st.warnings)
+                console.log(theme.warn('  ' + w));
             continue;
         }
         if (lower === '/skills') {
@@ -2771,6 +2896,34 @@ async function main() {
             show(t('memory.memory'), ctx.memory);
             continue;
         }
+        // `/remember <text>` — append a durable note to the project MEMORY.md.
+        // Claude Code has the same idea (# shortcut): a fact worth keeping across
+        // sessions is written to disk instead of living only in this chat. We
+        // write to the workdir's own MEMORY.md (the deepest file the loader reads)
+        // and create it when missing.
+        if (lower === '/remember' || lower.startsWith('/remember ')) {
+            const note = trimmed.slice('/remember'.length).trim();
+            if (!note) {
+                console.error(theme.warn(t('remember.usage')));
+                continue;
+            }
+            const memFile = path.join(currentWorkdir, 'MEMORY.md');
+            const stamp = new Date().toISOString().slice(0, 10);
+            let body;
+            try {
+                body = await fs.readFile(memFile, 'utf-8');
+            }
+            catch {
+                body = '# MEMORY\n\nDurable notes accumulated across sessions.\n';
+            }
+            if (body.length && !body.endsWith(NL))
+                body += NL;
+            body += NL + '- (' + stamp + ') ' + note + NL;
+            await fs.writeFile(memFile, body, 'utf-8');
+            transcript.log('remember', { note, file: memFile });
+            console.log(theme.assistant(t('remember.saved', { v: memFile })));
+            continue;
+        }
         if (lower === '/init' || lower.startsWith('/init ')) {
             const force = lower.includes('--force');
             const target = path.join(currentWorkdir, 'AGENTS.md');
@@ -2936,6 +3089,98 @@ async function main() {
             console.log(theme.system(transcript.file || t('common.off')));
             continue;
         }
+        if (lower === '/context') {
+            // Show what buildSystemPrompt() injects (AGENTS/MEMORY/skills/commands)
+            // so the operator can see why the context is large. Best-effort: a broken
+            // file must not break the command.
+            try {
+                const { loadProjectContext } = await import('./context.js');
+                const ctx = await loadProjectContext(currentWorkdir);
+                const sysLen = mod.buildSystemPrompt({
+                    workdir: currentWorkdir,
+                    tools: mod.createTools(currentWorkdir, { undo, todos: todoStore }),
+                    locale: currentLocale,
+                    context: ctx,
+                }).length;
+                console.log(theme.system(formatContextSources(ctx.agents, ctx.memory, ctx.skills, ctx.commands, { systemPromptChars: sysLen }, t)));
+            }
+            catch (e) {
+                console.error(theme.error(e.message));
+            }
+            continue;
+        }
+        if (lower === '/rename' || lower.startsWith('/rename ')) {
+            const title = trimmed.slice('/rename'.length).trim();
+            if (!title) {
+                console.log(theme.dim(t('rename.usage')));
+                continue;
+            }
+            if (!currentChatId) {
+                currentChatId = await browser.getCurrentChatId();
+            }
+            if (!currentChatId) {
+                console.error(theme.error(t('chats.not_created')));
+                continue;
+            }
+            saveLastChat(currentChatId, currentWorkdir, title);
+            console.log(theme.assistant(t('rename.done', { v: title })));
+            continue;
+        }
+        if (lower === '/copy') {
+            if (!lastAssistantMessage) {
+                console.log(theme.dim(t('copy.none')));
+                continue;
+            }
+            const res = writeClipboardText(lastAssistantMessage);
+            if (res.ok) {
+                console.log(theme.assistant(t('copy.done', { tool: res.via })));
+            }
+            else {
+                console.error(theme.warn(t('copy.failed', { tool: res.via })));
+            }
+            continue;
+        }
+        if (lower === '/retry') {
+            if (!lastTaskText) {
+                console.log(theme.dim(t('retry.none')));
+                continue;
+            }
+            console.log(theme.system(t('retry.running')));
+            // Re-send the last task into the SAME chat (no new chat, no system
+            // prompt), so a truncated/empty answer can be retried cheaply.
+            const tools = mod.createTools(currentWorkdir, {
+                undo,
+                todos: todoStore,
+                readOnly: planMode,
+            });
+            if (mcpPool)
+                tools.push(...mcpPool.tools);
+            if (editor)
+                editor.busy = true;
+            try {
+                await runTask(browser, tools, lastTaskText, currentWorkdir, {
+                    transcript,
+                    freshChat: false,
+                    sendSystemPrompt: false,
+                    queue: pendingQueue,
+                    ui: editor || null,
+                    onChatReady: (chatId) => {
+                        if (chatId) {
+                            currentChatId = chatId;
+                            saveLastChat(chatId, currentWorkdir);
+                        }
+                    },
+                    contextLimit: config.ui.contextLimit,
+                    getTokenUsage: () => browser.getLastTokenUsage(),
+                    goal: sessionGoal,
+                });
+            }
+            finally {
+                if (editor)
+                    editor.busy = false;
+            }
+            continue;
+        }
         if (lower === '/diff' || lower.startsWith('/diff ')) {
             const staged = lower.indexOf('--staged') !== -1;
             const { runGit } = await import('./gitTools.js');
@@ -2948,6 +3193,17 @@ async function main() {
             console.log(theme.system(formatDiff(out, { maxLines: 400 }, t)));
             continue;
         }
+        if (lower === '/diffstat') {
+            const { runGit } = await import('./gitTools.js');
+            const probe = await runGit('git rev-parse --is-inside-work-tree', currentWorkdir, 5000);
+            if (probe.trim() !== 'true') {
+                console.error(theme.error(t('diff.not_repo')));
+                continue;
+            }
+            const out = await runGit('git diff --stat', currentWorkdir, 20_000);
+            console.log(theme.system(formatDiffStat(out, { maxLines: 60 }, t)));
+            continue;
+        }
         if (lower === '/cost' || lower === '/usage') {
             let stats = summarizeTranscript([]);
             if (transcript.file) {
@@ -3037,15 +3293,6 @@ async function main() {
             }, t)));
             continue;
         }
-        if (lower === '/permissions' || lower === '/allowed-tools') {
-            console.log(theme.system(renderPermissions({
-                write: config.confirmation.write,
-                edit: config.confirmation.edit,
-                bash: config.confirmation.bash,
-                alwaysConfirm: config.confirmation.alwaysConfirm,
-            }, t)));
-            continue;
-        }
         if (lower === '/add-dir' || lower.startsWith('/add-dir ')) {
             const arg = trimmed.slice('/add-dir'.length).trim();
             const res = resolveExtraDir(arg, currentWorkdir, t);
@@ -3128,7 +3375,15 @@ async function main() {
                 transcript.log('undo', { path: result.record.originalPath });
             }
             else {
-                console.error(theme.error(t('undo.failed', { v: String(result.reason ?? '') })));
+                // undo.ts returns machine codes ('empty'/'disabled') — localize here so
+                // an English UI never shows a Russian reason.
+                const reasonKey = result.reason === 'empty'
+                    ? 'undo.reason_empty'
+                    : result.reason === 'disabled'
+                        ? 'undo.reason_disabled'
+                        : null;
+                const reason = reasonKey ? t(reasonKey) : String(result.reason ?? '');
+                console.error(theme.error(t('undo.failed', { v: reason })));
             }
             continue;
         }
@@ -3212,6 +3467,7 @@ async function main() {
         }
         // ---- Regular task (including in review mode) ----
         const taskText = expandedTask !== null ? expandedTask : trimmed;
+        lastTaskText = taskText;
         // Dev mode: pick up fresh logic modules before the task.
         await autoReload();
         // Re-scan skills/custom commands before every task: a SKILL.md or a
@@ -3221,7 +3477,11 @@ async function main() {
         if (editor)
             editor.setCommands(buildSlashCommands());
         transcript.log('user_task', { task: taskText, workdir: currentWorkdir });
-        const tools = mod.createTools(currentWorkdir, { undo, todos: todoStore });
+        const tools = mod.createTools(currentWorkdir, {
+            undo,
+            todos: todoStore,
+            readOnly: planMode,
+        });
         if (mcpPool)
             tools.push(...mcpPool.tools);
         if (editor)
@@ -3276,6 +3536,7 @@ async function main() {
                 contextLimit: config.ui.contextLimit,
                 getTokenUsage: () => browser.getLastTokenUsage(),
                 goal: sessionGoal,
+                todosQuery: () => todosSummary(),
             }, inputAttachments);
         }
         finally {

package/dist/input.js

@@ -1298,6 +1298,11 @@ export class LineEditor {
         // dots) and keep it running until toolResult()/assistant()/stop(). Esc now
         // really aborts the tool (the Bash child process is killed via the
         // AbortSignal), so the "Esc — стоп" hint is shown.
+        //
+        // The tool status is NOT a send phase: clear the lifecycle prefix first,
+        // otherwise the previous answer's "✓ done" sticks and the status reads
+        // "✓ done: running Bash" on one line.
+        this._sendState = '';
         this._startAnimated(translate(this.locale)('spinner.running_tool', { name }));
     }
     toolResult(result) {

package/dist/mcp.js

@@ -16,6 +16,24 @@ function packageVersion() {
     }
     return '0.0.0';
 }
+/**
+ * Flag stdio servers pinned to a floating version (`@latest` / `@next`).
+ * A floating version can change between runs and silently alter the tools the
+ * agent sees, so the operator is warned and told to pin an exact version.
+ * Pure; exported for tests.
+ */
+export function floatingVersionWarnings(servers) {
+    const out = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+        if (cfg.disabled)
+            continue;
+        const args = [String(cfg.command || ''), ...(cfg.args || [])].join(' ');
+        if (/@(latest|next)\b/.test(args)) {
+            out.push(name);
+        }
+    }
+    return out;
+}
 /** Names of the servers found in a config, before any connection. */
 export async function listConfiguredServers(workdir) {
     const files = await discoverConfigFiles(workdir);
@@ -298,6 +316,7 @@ export async function createMcpPool(opts) {
     const config = await loadConfigFiles(files);
     const servers = config.mcpServers || {};
     const names = Object.keys(servers).filter((n) => !servers[n].disabled);
+    const floating = floatingVersionWarnings(servers);
     const infos = [];
     const connections = [];
     const tools = [];
@@ -339,6 +358,7 @@ export async function createMcpPool(opts) {
         status: () => ({
             servers: infos,
             toolCount: tools.length,
+            warnings: floating.map((n) => `MCP server "${n}" uses a floating version (@latest/@next); pin an exact version so the tool set does not change between runs.`),
         }),
         close: async () => {
             if (closed)