zames_pro 2.61.0 → 2.63.1

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, isDevOnlyCommand, 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,6 +190,7 @@ const RELOADABLE = [
     'self-review',
     'diff',
     'undo',
+    'checkpoint',
     'transcript',
     'spinner',
     'config',
@@ -431,17 +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')}
-${devHelp}${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
@@ -484,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' },
@@ -539,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,
             });
         }
     }
@@ -551,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);
@@ -583,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 {
@@ -643,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 });
@@ -1101,6 +1167,27 @@ 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, selfImprovement = false, } = opts;
     // In TTY mode the UI is a LineEditor: it owns the input (queue, Esc,
@@ -1198,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,
@@ -1355,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 {
@@ -3142,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'),
             })));
@@ -3597,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`);
@@ -3652,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 })));
@@ -3663,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
@@ -3672,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,
@@ -3683,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,
@@ -3709,7 +3929,7 @@ async function main() {
                             currentChatId,
                             workdir: currentWorkdir,
                             locale: currentLocale,
-                            task: taskText,
+                            task: finalTaskText,
                             transcript,
                             ui: editor,
                             buildSystemPrompt: mod.buildSystemPrompt,

package/dist/input.js

@@ -692,10 +692,11 @@ export class LineEditor {
         const shown = sugg.slice(off, off + pageSize);
         this._suggestOffset = off;
         this._suggestCount = sugg.length;
-        const maxName = Math.max(...shown.map((c) => c.name.length));
+        const label = (c) => c.hint ? c.name + ' ' + c.hint : c.name;
+        const maxName = Math.max(...shown.map((c) => label(c).length));
         const lines = shown.map((c, i) => {
             const selected = off + i === this._suggestSelected && this._suggestSelected > 0;
-            const name = theme.prompt(c.name.padEnd(maxName));
+            const name = theme.prompt(label(c).padEnd(maxName));
             const desc = theme.dim('  ' + c.description);
             return (selected ? theme.prompt(' ▸ ') : '   ') + name + desc;
         });
@@ -1266,7 +1267,13 @@ export class LineEditor {
         const label = translate(this.locale)('spinner.pause', { n: seconds });
         if (this._animating && this._dotTimer) {
             this._thinkBase = theme.brown(stripEllipsis(label));
-            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
+            // Keep the SAME tail as the dot timer renders (elapsed + hint). Omitting
+            // the elapsed label here made it blink once per second: the timer showed
+            // "· 1m 50s" and the per-second sendPause update erased it.
+            this.setStatus(this._thinkBase +
+                this._dots(this._dotPhase) +
+                this._elapsedLabel() +
+                this._hint());
             return;
         }
         this._startAnimated(label);

package/dist/path-token.js

@@ -51,6 +51,81 @@ function stripPunct(tok) {
         t = t.slice(1);
     return t;
 }
+// Characters that may directly precede an '@' for it to count as a file
+// reference rather than a decorator/email. Without this guard `user@host` and
+// `@Component` would be misread as paths.
+function isRefBoundary(ch) {
+    return (ch === ' ' ||
+        ch === '\t' ||
+        ch === '\n' ||
+        ch === '\r' ||
+        ch === '(' ||
+        ch === '[' ||
+        ch === '{' ||
+        ch === String.fromCharCode(34) ||
+        ch === String.fromCharCode(39) ||
+        ch === '<');
+}
+// End of a reference token: whitespace, a closing bracket/quote, or an
+// angle bracket (so `@a.ts>` stops at `>`).
+function isRefEnd(ch) {
+    return (ch === ' ' ||
+        ch === '\t' ||
+        ch === '\n' ||
+        ch === '\r' ||
+        ch === ')' ||
+        ch === ']' ||
+        ch === '}' ||
+        ch === String.fromCharCode(34) ||
+        ch === String.fromCharCode(39) ||
+        ch === '<' ||
+        ch === '>');
+}
+// Strip trailing punctuation a path may have picked up from prose, e.g.
+// "see @src/a.ts, please" -> `src/a.ts`.
+function stripRefPunct(tok) {
+    let t = tok;
+    while (t.length && ',.;:!?'.includes(t[t.length - 1]))
+        t = t.slice(0, -1);
+    return t;
+}
+// Find all `@path` references in a task text (B5). Returns the unique paths in
+// order of appearance. A reference is an '@' at a word boundary followed by a
+// token that looks like a file name/path (a known extension). Implemented
+// without regular expressions, like extractPathToken, to keep the source free
+// of escaping pitfalls.
+export function extractAtFileRefs(text) {
+    const s = String(text || '');
+    const chars = Array.from(s);
+    const n = chars.length;
+    const out = [];
+    const seen = new Set();
+    let i = 0;
+    while (i < n) {
+        if (chars[i] !== '@') {
+            i++;
+            continue;
+        }
+        const prev = i > 0 ? chars[i - 1] : '';
+        if (prev && !isRefBoundary(prev)) {
+            i++;
+            continue;
+        }
+        let j = i + 1;
+        let tok = '';
+        while (j < n && !isRefEnd(chars[j])) {
+            tok += chars[j];
+            j++;
+        }
+        const cleaned = stripRefPunct(tok);
+        if (cleaned && looksLikeToken(cleaned) && !seen.has(cleaned)) {
+            seen.add(cleaned);
+            out.push(cleaned);
+        }
+        i = j > i + 1 ? j : i + 1;
+    }
+    return out;
+}
 function looksLikeToken(tok) {
     const t = String(tok || '');
     if (!t || t.length > 500)

package/dist/permissions.js

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import path from 'path';
+export function permissionsPath(workdir) {
+    return path.join(workdir, '.zames', 'permissions.json');
+}
+const ACTIONS = ['allow', 'deny', 'ask'];
+function normAltion(v) {
+    if (typeof v !== 'string')
+        return null;
+    const s = v.toLowerCase();
+    return ACTIONS.includes(s) ? s : null;
+}
+/** Parse the JSON of a permissions file into a policy, or null when empty/broken. */
+export function parsePermissions(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const defAction = normAltion(obj['default']) ?? 'allow';
+    const rules = Array.isArray(obj['rules']) ? obj['rules'] : [];
+    const out = [];
+    for (const item of rules) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const e = item;
+        const action = normAltion(e['action']);
+        if (!action)
+            continue;
+        out.push({
+            action,
+            tool: typeof e['tool'] === 'string' ? e['tool'] : undefined,
+            command: typeof e['command'] === 'string' ? e['command'] : undefined,
+            path: typeof e['path'] === 'string' ? e['path'] : undefined,
+        });
+    }
+    if (!out.length && defAction === 'allow')
+        return null;
+    return { default: defAction, rules: out };
+}
+/** Read `.zames/permissions.json`. Missing/broken => null (no policy). */
+export function loadPermissions(workdir) {
+    let raw;
+    try {
+        raw = fs.readFileSync(permissionsPath(workdir), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    try {
+        return parsePermissions(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+function safeRegex(source) {
+    try {
+        return new RegExp(source);
+    }
+    catch {
+        return null;
+    }
+}
+// A file path may arrive in any of these keys depending on the tool.
+// We collect them all and match the path regex against ANY of them.
+const PATH_KEYS = ['path', 'file_path', 'notebook_path', 'from', 'to'];
+export function decidePermission(policy, tool, args) {
+    if (!policy)
+        return { action: 'allow', reason: 'no policy' };
+    const a = (args ?? {});
+    const command = typeof a['command'] === 'string' ? a['command'] : '';
+    const paths = PATH_KEYS.map((k) => a[k]).filter((v) => typeof v === 'string');
+    for (const r of policy.rules) {
+        if (r.tool) {
+            const re = safeRegex(r.tool);
+            if (!re || !re.test(tool))
+                continue;
+        }
+        if (r.command) {
+            const re = safeRegex(r.command);
+            if (!re || !command || !re.test(command))
+                continue;
+        }
+        if (r.path) {
+            const re = safeRegex(r.path);
+            if (!re || !paths.some((p) => re.test(p)))
+                continue;
+        }
+        const desc = [
+            r.tool ? 'tool=' + r.tool : '',
+            r.command ? 'command=' + r.command : '',
+            r.path ? 'path=' + r.path : '',
+        ]
+            .filter(Boolean)
+            .join(' ');
+        return { action: r.action, reason: 'rule ' + desc };
+    }
+    return { action: policy.default, reason: 'default' };
+}

package/dist/spinner.js

@@ -151,7 +151,10 @@ export function createSpinner(locale = 'ru') {
             // so the countdown refreshes without resetting the dots.
             if (animating && dotTimer && spinner) {
                 animBase = theme.brown(stripEllipsis(label));
-                spinner.text = animBase + renderDots(dotPhase) + elapsedLabel() + HINT;
+                // Same tail as the timer renders (elapsed + tasks + hint), or the
+                // per-second update blinks the elapsed label / task badge away.
+                spinner.text =
+                    animBase + renderDots(dotPhase) + elapsedLabel() + tasksBadge() + HINT;
                 return;
             }
             startAnimated(label);

package/dist/system-prompt.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import { translate } from './i18n.js';
 // The dev-mode BACKLOG instruction. English (agent-facing) like the rest of the
 // prompt. Deliberately narrow: one short note at most, and only when the idea
@@ -45,6 +46,20 @@ export function renderContextSection(context) {
                 f.content +
                 '\n';
     }
+    // B6: nested AGENTS.md/MEMORY.md from the directories this task touches.
+    // Deliberately a SEPARATE section: these apply only to part of the tree and
+    // must not be mistaken for project-wide rules.
+    for (const f of context.scopedAgents || []) {
+        out +=
+            '\n## Scoped instructions (' +
+                f.path +
+                ')\n\n' +
+                'These rules apply ONLY to files under ' +
+                path.dirname(f.path) +
+                ' (the current task touches that directory). Follow them for those files, in addition to the project instructions above.\n\n' +
+                f.content +
+                '\n';
+    }
     if (context.memory.length) {
         out +=
             '\nWhen you learn a durable fact about this project or the operator preferences (build quirks, ' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.61.0",
+  "version": "2.63.1",
   "description": "Terminal coding agent that drives chat.deepseek.com through Playwright: reads and edits files, runs commands, commits to git.",
   "type": "module",
   "bin": {
@@ -12,7 +12,8 @@
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
-    "logo.jpg"
+    "logo.jpg",
+    "logo-small.jpg"
   ],
   "scripts": {
     "start": "node ./dist/index.js",

package/scripts/coverage-gate.mjs

@@ -28,6 +28,8 @@ const FLOORS = {
   'tools.ts': 90,
   'system-prompt.ts': 90,
   'undo.ts': 85,
+  'checkpoint.ts': 80,
+  'permissions.ts': 85,
 }
 
 const run = spawnSync(