zames_pro 2.60.0 → 2.63.0

package/dist/index.js

@@ -17,11 +17,13 @@ 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 { 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, parseBacklogItems, nextBacklogItem, buildImprovePrompt, 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, 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 { performCompact } from './compact.js';
 import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } from './scheduler.js';
 import { renderMarkdown, setAnswerWidth } from './markdown.js';
+import { extractAtFileRefs } from './path-token.js';
 import { closeWeb } from './web.js';
 import { assertCommandInsideRoot, runShell } from './shell.js';
 import { saveSession, loadLastSession, readSession, listSessions, sessionsDir, loadHistory, saveHistory, } from './sessions.js';
@@ -188,10 +190,12 @@ const RELOADABLE = [
     'self-review',
     'diff',
     'undo',
+    'checkpoint',
     'transcript',
     'spinner',
     'config',
     'fsutil',
+    'backlog',
 ];
 const mod = {
     createTools,
@@ -204,6 +208,10 @@ const mod = {
     closeWeb,
     createSpinner,
     createMcpPool: null,
+    collapseBacklog: null,
+    appendBacklogItem: null,
+    backlogStats: null,
+    backlogNeedsPruning: null,
 };
 async function reloadModules() {
     const stamp = Date.now();
@@ -242,6 +250,14 @@ async function reloadModules() {
         mod.createSpinner = pick('spinner', 'createSpinner');
     if (pick('mcp', 'createMcpPool'))
         mod.createMcpPool = pick('mcp', 'createMcpPool');
+    if (pick('backlog', 'collapseBacklog'))
+        mod.collapseBacklog = pick('backlog', 'collapseBacklog');
+    if (pick('backlog', 'appendBacklogItem'))
+        mod.appendBacklogItem = pick('backlog', 'appendBacklogItem');
+    if (pick('backlog', 'backlogStats'))
+        mod.backlogStats = pick('backlog', 'backlogStats');
+    if (pick('backlog', 'backlogNeedsPruning'))
+        mod.backlogNeedsPruning = pick('backlog', 'backlogNeedsPruning');
     return { count: loaded.size, errors };
 }
 // Initial load so that mod.buildSystemPrompt and the rest are populated.
@@ -297,6 +313,42 @@ function warnIfBrowserChanged() {
 }
 // ---------- helpers ----------
 function printHelp() {
+    // Self-development commands (backlog / self-review) are shown ONLY in dev
+    // mode. A regular package install must not advertise them to the user — and
+    // the main loop rejects them too (see the guard at the dispatch).
+    const devHelp = devMode
+        ? '  ' +
+            t('help.cmd.improve') +
+            '\n  ' +
+            t('help.cmd.backlog') +
+            '\n  ' +
+            t('help.cmd.debug_dom') +
+            '\n  ' +
+            t('help.cmd.help') +
+            '\n  ' +
+            t('help.cmd.exit') +
+            '\n\n' +
+            theme.bold(t('help.self_review')) +
+            '\n  ' +
+            t('help.self.review') +
+            '\n  ' +
+            t('help.self.fix') +
+            '\n  ' +
+            t('help.self.done') +
+            '\n  ' +
+            t('help.self.list') +
+            '\n  ' +
+            t('help.self.diff') +
+            '\n  ' +
+            t('help.self.apply') +
+            '\n\n'
+        : '  ' +
+            t('help.cmd.debug_dom') +
+            '\n  ' +
+            t('help.cmd.help') +
+            '\n  ' +
+            t('help.cmd.exit') +
+            '\n';
     console.log(`
 ${theme.bold('zames')} — ${t('app.tagline')}
 
@@ -382,29 +434,20 @@ ${theme.bold(t('help.sec.files'))}
   ${t('help.cmd.transcript')}
   ${t('help.cmd.undo')}
   ${t('help.cmd.undo_list')}
+  ${t('help.cmd.rewind')}
+  ${t('help.cmd.rewind_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.improve')}
-  ${t('help.cmd.debug_dom')}
-  ${t('help.cmd.help')}
-  ${t('help.cmd.exit')}
-
-${theme.bold(t('help.self_review'))}
-  ${t('help.self.review')}
-  ${t('help.self.fix')}
-  ${t('help.self.done')}
-  ${t('help.self.list')}
-  ${t('help.self.diff')}
-  ${t('help.self.apply')}
-${dynamicCommands.length ? '\n' + theme.bold(t('help.skills')) + '\n' + dynamicCommands.map((d) => '  ' + d.name.padEnd(24) + ' ' + d.description).join('\n') : ''}
+${devHelp}${dynamicCommands.length ? '\n' + theme.bold(t('help.skills')) + '\n' + dynamicCommands.map((d) => '  ' + (d.hint ? d.name + ' ' + d.hint : d.name).padEnd(24) + ' ' + d.description).join('\n') : ''}
 
 ${theme.bold(t('help.files'))}
   ${t('help.files.logs')}        ${config.transcript.dir}
   ${t('help.files.undo')}        ~/.zames/undo
+  ${t('help.files.checkpoints')}   ~/.zames/checkpoints
   ${t('help.files.sessions')}      ${sessionsDir()}
   ${t('help.files.profile')}     ~/.zames/profile
   ${t('help.files.snapshots')}    ~/.zames/snapshots
@@ -421,6 +464,12 @@ function dirLabel(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' },
@@ -441,6 +490,8 @@ const SLASH_COMMANDS = [
     { 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' },
@@ -450,6 +501,7 @@ const SLASH_COMMANDS = [
     { 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' },
@@ -495,9 +547,12 @@ async function refreshDynamicCommands(workdir) {
         }
         const cmds = await loadCommands(workdir);
         for (const c of cmds) {
+            // B7: carry the declared argument hint as a separate field so the hint is
+            // SHOWN in the suggest list but never inserted into the input line.
             out.push({
                 name: '/' + c.name,
                 description: c.description || t('help.cmd.custom'),
+                hint: c.argumentHint,
             });
         }
     }
@@ -507,16 +562,22 @@ async function refreshDynamicCommands(workdir) {
     dynamicCommands = out;
 }
 // Expand a slash target (skill or custom command) into a task string.
-// Returns null when the name is neither a skill nor a custom command.
+// Returns null when the name is neither a skill nor a custom command. When a
+// custom command declares mandatory `arguments:` and some are missing, returns
+// `{ missing }` so the caller can print the usage hint instead of sending an
+// incomplete prompt.
 async function expandSlashTarget(workdir, name, rest) {
     try {
         const { loadSkills, loadCommands, skillBody } = await import('./context.js');
         const commands = await loadCommands(workdir);
         const cmd = commands.find((c) => c.name.toLowerCase() === name.toLowerCase());
         if (cmd) {
-            let body = cmd.body.replace(/\{\{args\}\}/g, rest);
-            body = body.replace(/\$ARGUMENTS/g, rest);
-            return body.trim() || rest;
+            // B7: refuse to run when declared positional arguments are missing.
+            const missing = missingCommandArgs(cmd.arguments, rest);
+            if (missing.length)
+                return { missing };
+            const body = expandCommandArgs(cmd.body, rest, cmd.arguments);
+            return { text: body || rest };
         }
         const skills = await loadSkills(workdir);
         const skill = skills.find((s) => s.name.toLowerCase() === name.toLowerCase() && s.userInvokable);
@@ -539,7 +600,7 @@ async function expandSlashTarget(workdir, name, rest) {
             const extra = rest
                 ? '\n\nAdditional instructions from the operator: ' + rest
                 : '';
-            return header + '\n\n' + body + extra;
+            return { text: header + '\n\n' + body + extra };
         }
     }
     catch {
@@ -548,8 +609,10 @@ async function expandSlashTarget(workdir, name, rest) {
     return null;
 }
 // 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.
 function buildSlashCommands() {
-    const base = SLASH_COMMANDS.map((c) => ({
+    const base = SLASH_COMMANDS.filter((c) => devMode || !isDevOnlyCommand(c.name)).map((c) => ({
         name: c.name,
         description: t(c.key),
     }));
@@ -597,6 +660,55 @@ async function resolveAttachPath(workdir, raw) {
     }
     return null;
 }
+// Per-file and total caps for `@path` inlining (B5). A reference should SAVE
+// round-trips, not flood the context: a huge file is truncated with a note
+// telling the agent to read the rest itself.
+const AT_REF_FILE_CAP = 60 * 1024;
+const AT_REF_TOTAL_CAP = 200 * 1024;
+// Inline `@path` references found in a task text (B5). Returns the augmented
+// text plus the list of files actually inlined (for the operator notice).
+// Unknown/unreadable references are left in place untouched — they may be part
+// of the prose; we never fail the task over a missing file.
+async function inlineAtRefs(workdir, text) {
+    const refs = extractAtFileRefs(text);
+    if (!refs.length)
+        return { text, inlined: [] };
+    const blocks = [];
+    const inlined = [];
+    let total = 0;
+    for (const ref of refs) {
+        if (total >= AT_REF_TOTAL_CAP)
+            break;
+        const file = await resolveAttachPath(workdir, ref);
+        if (!file)
+            continue;
+        let raw;
+        try {
+            raw = await fs.readFile(file, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        let body = raw;
+        let note = '';
+        if (body.length > AT_REF_FILE_CAP) {
+            body = body.slice(0, AT_REF_FILE_CAP);
+            note = NL + NL + '(truncated at ' + AT_REF_FILE_CAP + ' chars)';
+        }
+        total += body.length;
+        inlined.push(path.relative(workdir, file) || file);
+        blocks.push('### ' + ref + NL + '```' + NL + body + NL + '```' + note);
+    }
+    if (!blocks.length)
+        return { text, inlined: [] };
+    const section = NL +
+        NL +
+        '## Files referenced with @ in the task' +
+        NL +
+        NL +
+        blocks.join(NL + NL);
+    return { text: text + section, inlined };
+}
 async function cleanTmpDir() {
     try {
         await fs.rm(TMP_DIR, { recursive: true, force: true });
@@ -1055,8 +1167,29 @@ async function printRestoredHistory(browser, ui, chatId = null) {
     }
 }
 // ---------- 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, } = opts;
+    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.
@@ -1152,6 +1285,19 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                     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,
@@ -1166,6 +1312,7 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                 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
@@ -1308,6 +1455,7 @@ async function main() {
         console.log(theme.system(t('msg.transcript', { v: transcript.file })));
     }
     const undo = new UndoStore(config.undo);
+    const checkpoints = new CheckpointStore(config.checkpoint);
     // MCP servers: optional external tool providers (e.g. @playwright/mcp).
     let mcpPool = null;
     try {
@@ -1402,6 +1550,7 @@ async function main() {
             transcript,
             freshChat,
             sendSystemPrompt,
+            selfImprovement: devMode,
             onChatReady: (chatId) => {
                 if (chatId)
                     saveLastChat(chatId, currentWorkdir);
@@ -1423,6 +1572,21 @@ async function main() {
     if (!authMarkerExists()) {
         console.log(theme.warn(t('msg.first_login_hint')));
     }
+    // Nudge when BACKLOG.md has grown large: /improve reads the whole file, so a
+    // bloated backlog costs tokens on every self-improvement run. Best-effort.
+    if (devMode) {
+        try {
+            const bl = await fs.readFile(path.join(currentWorkdir, 'BACKLOG.md'), 'utf-8');
+            const st = mod.backlogStats(bl);
+            if (mod.backlogNeedsPruning(st)) {
+                console.log(theme.warn(t('backlog.warn', {
+                    lines: String(st.lines),
+                    chars: String(st.chars),
+                })));
+            }
+        }
+        catch { }
+    }
     let freshChatNext = true;
     let sendSystemPromptNext = true;
     // Resuming an existing chat already has the system-prompt at its start, so
@@ -2226,6 +2390,16 @@ async function main() {
         const lower = trimmed.toLowerCase();
         if (['/exit', '/quit', 'exit', 'quit'].includes(lower))
             break;
+        // Dev-only commands (backlog / self-review) must not run outside dev mode.
+        // Hiding them from /help is not enough: a user could type the command by
+        // hand, and it would rewrite their project's BACKLOG.md or snapshot src/.
+        if (!devMode) {
+            const devCmd = isDevOnlyCommand(lower);
+            if (devCmd) {
+                console.error(theme.warn(t('msg.dev_only', { v: devCmd })));
+                continue;
+            }
+        }
         // `!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.
@@ -3069,6 +3243,9 @@ async function main() {
             console.log(theme.system(t('status.undo', {
                 v: config.undo.enabled ? t('common.on') : t('common.off'),
             })));
+            console.log(theme.system(t('status.checkpoint', {
+                v: config.checkpoint.enabled ? t('common.on') : t('common.off'),
+            })));
             console.log(theme.system(t('status.transcript', {
                 v: transcript.file || t('common.off'),
             })));
@@ -3328,6 +3505,7 @@ async function main() {
                 tools: mod.createTools(currentWorkdir, { undo, todos: todoStore }),
                 answerTimeoutMs: config.browser.answerTimeoutMs,
                 fallbackLimit: COMPACT_FALLBACK_LIMIT,
+                selfImprovement: devMode,
             });
             if (res.ok) {
                 currentChatId = res.chatId;
@@ -3382,12 +3560,80 @@ async function main() {
                         }
                     },
                     getTokenUsage: () => browser.getLastTokenUsage(),
+                    selfImprovement: devMode,
                 });
             }
             finally {
                 if (editor)
                     editor.busy = false;
             }
+            // Auto-prune: a finished item keeps its summary line but loses the
+            // archived <details> copy of its original text, so BACKLOG.md does not
+            // grow on every /improve. Best-effort — a read/write failure must not
+            // break the command.
+            try {
+                const raw = await fs.readFile(path.join(currentWorkdir, 'BACKLOG.md'), 'utf-8');
+                const col = mod.collapseBacklog(raw);
+                if (col.changed) {
+                    await fs.writeFile(path.join(currentWorkdir, 'BACKLOG.md'), col.text, 'utf-8');
+                    console.log(theme.dim(t('improve.collapsed', { n: String(col.collapsed) })));
+                }
+            }
+            catch { }
+            continue;
+        }
+        if (lower === '/backlog' || lower.startsWith('/backlog ')) {
+            // Record an improvement idea without implementing it. `/backlog
+            // collapse` prunes the archived blocks instead. The LLM only PLACES
+            // the item; the pure helpers in src/backlog.ts own the format.
+            const note = trimmed.slice('/backlog'.length).trim();
+            const backlogFile = path.join(currentWorkdir, 'BACKLOG.md');
+            let backlogText;
+            try {
+                backlogText = await fs.readFile(backlogFile, 'utf-8');
+            }
+            catch {
+                console.error(theme.warn(t('backlog.none')));
+                continue;
+            }
+            if (!note) {
+                console.log(theme.dim(t('backlog.usage')));
+                continue;
+            }
+            if (note === 'collapse') {
+                const col = mod.collapseBacklog(backlogText);
+                if (!col.changed) {
+                    console.log(theme.dim(t('backlog.empty')));
+                }
+                else {
+                    await fs.writeFile(backlogFile, col.text, 'utf-8');
+                    console.log(theme.system(t('improve.collapsed', { n: String(col.collapsed) })));
+                }
+                continue;
+            }
+            // 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,
+            });
+            await fs.writeFile(backlogFile, res.text, 'utf-8');
+            console.log(theme.system(t('backlog.adding', { v: res.id })));
             continue;
         }
         if (lower === '/review' || lower.startsWith('/review ')) {
@@ -3455,6 +3701,86 @@ async function main() {
             }
             continue;
         }
+        if (lower === '/rewind-list' || lower === '/checkpoints') {
+            const list = await checkpoints.list(10);
+            if (!list.length) {
+                console.log(theme.system(t('rewind.empty')));
+            }
+            else {
+                console.log(theme.system(t('rewind.list_title')));
+                list.forEach((r, i) => {
+                    const stamp = new Date(r.stamp).toLocaleString();
+                    const label = r.label ? '  [' + t('rewind.label_backup') + ']' : '';
+                    console.log(theme.system(`  ${i + 1}. ${stamp}  ${r.workdir}${label}`));
+                });
+            }
+            continue;
+        }
+        if (lower === '/rewind' || lower.startsWith('/rewind ')) {
+            const selector = trimmed.slice('/rewind'.length).trim() || '1';
+            if (editor)
+                editor.lock(t('msg.input_locked'));
+            try {
+                const list = await checkpoints.list(10);
+                const target = pickCheckpoint(list, selector);
+                if (!target) {
+                    console.error(theme.error(t('rewind.failed', { v: selector })));
+                    continue;
+                }
+                // Confirmation: a rewind overwrites the working tree, so it must never
+                // happen on a muscle-memory Enter.
+                const stamp = new Date(target.stamp).toLocaleString();
+                let answer = 'n';
+                if (process.stdin.isTTY && process.stdout.isTTY) {
+                    // promptOnce reads stdin itself. While the LineEditor owns the
+                    // terminal we must hand it over first (the same pause/resume the
+                    // /config menu uses), or both readers fight for the same keys.
+                    if (editor)
+                        editor.pause();
+                    try {
+                        answer = await promptOnce(theme.warn(t('rewind.confirm', { v: stamp })) + ' [y/N] ');
+                    }
+                    finally {
+                        if (editor)
+                            editor.resume();
+                    }
+                }
+                else if (trimmed.indexOf('--yes') !== -1) {
+                    // Non-TTY (piped): do not guess. Require an explicit --yes.
+                    answer = 'y';
+                }
+                if (!/^(y|yes|д|да)$/i.test(answer.trim())) {
+                    console.log(theme.system(t('rewind.cancelled')));
+                    continue;
+                }
+                const res = await checkpoints.restore(selector);
+                if (res.ok && res.record) {
+                    console.log(theme.assistant(t('rewind.reverted', { v: String(res.record.stamp) })));
+                    if (res.backup) {
+                        console.log(theme.system(t('rewind.backup', { v: String(res.backup.stamp) })));
+                    }
+                    transcript.log('rewind', { stamp: res.record.stamp });
+                }
+                else {
+                    const reasonKey = res.reason === 'not_found'
+                        ? 'rewind.reason_not_found'
+                        : res.reason === 'archive_missing'
+                            ? 'rewind.reason_archive_missing'
+                            : res.reason === 'extract_failed'
+                                ? 'rewind.reason_extract_failed'
+                                : res.reason === 'disabled'
+                                    ? 'rewind.reason_disabled'
+                                    : null;
+                    const reason = reasonKey ? t(reasonKey) : String(res.reason ?? '');
+                    console.error(theme.error(t('rewind.failed', { v: reason })));
+                }
+            }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
+            continue;
+        }
         if (lower === '/debug-dom') {
             const stamp = new Date().toISOString().replace(/[:.]/g, '-');
             const file = path.join(config.transcript.dir, `dom-${stamp}.html`);
@@ -3510,10 +3836,21 @@ async function main() {
         // task. Skills are instructions the agent follows; custom commands are
         // prompt templates with $ARGUMENTS / {{args}} placeholders.
         let expandedTask = null;
+        let missingArgs = null;
         if (lower.startsWith('/')) {
             const name = trimmed.slice(1).split(/\s+/)[0];
             const rest = trimmed.slice(1 + name.length).trim();
-            expandedTask = await expandSlashTarget(currentWorkdir, name, rest);
+            const res = await expandSlashTarget(currentWorkdir, name, rest);
+            if (res && 'missing' in res)
+                missingArgs = res.missing;
+            else if (res)
+                expandedTask = res.text;
+        }
+        // B7: a custom command with mandatory `arguments:` refuses to run until the
+        // operator supplies them (by position).
+        if (missingArgs) {
+            console.error(theme.error(t('msg.missing_args', { v: missingArgs.join(', ') })));
+            continue;
         }
         if (lower.startsWith('/') && expandedTask === null) {
             console.error(theme.error(t('msg.unknown_cmd', { v: trimmed })));
@@ -3521,7 +3858,20 @@ async function main() {
         }
         // ---- Regular task (including in review mode) ----
         const taskText = expandedTask !== null ? expandedTask : trimmed;
-        lastTaskText = taskText;
+        // B5: inline any `@path` references into the task so the agent does not
+        // spend a round-trip reading a file the operator already pointed at. Only
+        // existing files are inlined; a bare `@name` in prose is left untouched.
+        let finalTaskText = taskText;
+        {
+            const refRes = await inlineAtRefs(currentWorkdir, taskText);
+            if (refRes.inlined.length) {
+                finalTaskText = refRes.text;
+                console.log(theme.system(t('msg.at_refs', { n: refRes.inlined.length }) +
+                    ' ' +
+                    refRes.inlined.join(', ')));
+            }
+        }
+        lastTaskText = finalTaskText;
         // 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
@@ -3530,7 +3880,19 @@ async function main() {
         await refreshDynamicCommands(currentWorkdir);
         if (editor)
             editor.setCommands(buildSlashCommands());
-        transcript.log('user_task', { task: taskText, workdir: currentWorkdir });
+        transcript.log('user_task', {
+            task: finalTaskText,
+            workdir: currentWorkdir,
+        });
+        // BACKLOG B3: snapshot the working tree BEFORE the task so /rewind can
+        // undo the whole task in one step. Best-effort: create() never throws, so
+        // a missing tar cannot abort the task it was meant to protect. Skipped
+        // while reviewing a snapshot (workdir is a throwaway copy).
+        if (!reviewMode) {
+            const cp = await checkpoints.create(currentWorkdir);
+            if (cp)
+                transcript.log('checkpoint', { stamp: cp.stamp });
+        }
         const tools = mod.createTools(currentWorkdir, {
             undo,
             todos: todoStore,
@@ -3541,7 +3903,7 @@ async function main() {
         if (editor)
             editor.busy = true;
         try {
-            await runTask(browser, tools, taskText, currentWorkdir, {
+            await runTask(browser, tools, finalTaskText, currentWorkdir, {
                 transcript,
                 freshChat: freshChatNext,
                 sendSystemPrompt: sendSystemPromptNext,
@@ -3567,7 +3929,7 @@ async function main() {
                             currentChatId,
                             workdir: currentWorkdir,
                             locale: currentLocale,
-                            task: taskText,
+                            task: finalTaskText,
                             transcript,
                             ui: editor,
                             buildSystemPrompt: mod.buildSystemPrompt,
@@ -3578,6 +3940,7 @@ async function main() {
                             answerTimeoutMs: config.browser.answerTimeoutMs,
                             quiet: true,
                             skipUiLock: true,
+                            selfImprovement: devMode,
                         });
                         if (res.ok) {
                             currentChatId = res.chatId;
@@ -3591,6 +3954,7 @@ async function main() {
                 getTokenUsage: () => browser.getLastTokenUsage(),
                 goal: sessionGoal,
                 todosQuery: () => todosSummary(),
+                selfImprovement: devMode,
             }, inputAttachments);
         }
         finally {