zames_pro 2.13.0 → 2.15.0

package/dist/extraTools.js

@@ -0,0 +1,352 @@
+import fs from 'fs/promises';
+import path from 'path';
+// Extra tools that bring zames closer to Claude Code / Codex CLI:
+//   * LS         - list a directory (Claude Code has LS; Codex has list_dir)
+//   * MultiEdit  - several edits to ONE file applied atomically (Claude Code)
+//   * ApplyPatch - multi-file V4A-style patch (Codex apply_patch)
+//   * TodoWrite  - session task checklist (Claude Code TodoWrite)
+//
+// The core file tools (Read/Write/Edit/Bash/Glob/Grep) live in tools.ts.
+// These are additive: they do not change the existing tool behaviour.
+const NL = String.fromCharCode(10);
+function decodeContent(content, contentBase64) {
+    if (typeof contentBase64 === 'string' && contentBase64.length) {
+        return Buffer.from(contentBase64, 'base64').toString('utf-8');
+    }
+    return String(content ?? '');
+}
+// The todo list is per-process session state. It is deliberately NOT
+// persisted: a fresh run starts with an empty list, like Claude Code's
+// session checklist.
+const todoList = [];
+export function getTodos() {
+    return todoList.map((t) => ({ ...t }));
+}
+export function resetTodos() {
+    todoList.length = 0;
+}
+export function renderTodos(items) {
+    if (!items.length)
+        return 'Todo list is empty.';
+    const mark = (s) => s === 'completed' ? '[x]' : s === 'in_progress' ? '[~]' : '[ ]';
+    const lines = items.map((t, i) => `${i + 1}. ${mark(t.status)} ${t.content}`);
+    const done = items.filter((t) => t.status === 'completed').length;
+    return `Todo list (${done}/${items.length} done):${NL}${lines.join(NL)}`;
+}
+export function normalizeTodos(list) {
+    const items = [];
+    for (const raw of list) {
+        const it = (raw || {});
+        const content = String(it.content ?? it.text ?? '').trim();
+        if (!content)
+            continue;
+        const s = String(it.status ?? 'pending');
+        const status = s === 'completed' || s === 'done'
+            ? 'completed'
+            : s === 'in_progress' || s === 'active'
+                ? 'in_progress'
+                : 'pending';
+        items.push({ content, status });
+    }
+    return items;
+}
+/** Parse a V4A-style patch body into operations. Exported for tests. */
+export function parsePatch(text) {
+    const raw = String(text ?? '').replace(/\r\n/g, NL);
+    if (!/^\s*\*\*\*\s*Begin Patch/m.test(raw)) {
+        return { ops: [], error: 'Patch must start with "*** Begin Patch".' };
+    }
+    if (!/\*\*\*\s*End Patch/.test(raw)) {
+        return { ops: [], error: 'Patch must end with "*** End Patch".' };
+    }
+    const beginIdx = raw.indexOf('*** Begin Patch');
+    const endIdx = raw.lastIndexOf('*** End Patch');
+    const beginLineEnd = raw.indexOf(NL, beginIdx);
+    const body = raw.slice(beginLineEnd === -1 ? beginIdx : beginLineEnd + 1, endIdx);
+    const ops = [];
+    let current = null;
+    for (const line of body.split(NL)) {
+        const header = line.match(/^\*\*\*\s*(Add|Update|Delete) File:\s*(.+?)\s*$/);
+        if (header) {
+            const kind = header[1].toLowerCase();
+            const file = header[2].trim();
+            if (!file)
+                return { ops: [], error: 'Patch header has an empty path.' };
+            if (path.isAbsolute(file) || /(^|[\\/])\.\.([\\/]|$)/.test(file)) {
+                return { ops: [], error: 'Patch path must stay inside the project: ' + file };
+            }
+            current = { op: kind, file, lines: [] };
+            ops.push(current);
+            continue;
+        }
+        if (current)
+            current.lines.push(line);
+    }
+    if (!ops.length)
+        return { ops: [], error: 'Patch contains no file operations.' };
+    return { ops };
+}
+/**
+ * Apply an update hunk to existing content using context matching.
+ * The hunk is a list of lines prefixed with ' ' (context), '-' (remove),
+ * '+' (add). We locate the context block by exact match, then by ignoring
+ * trailing whitespace, then by ignoring all whitespace (like Codex).
+ */
+export function applyUpdateHunk(content, hunkLines) {
+    const hasCRLF = content.includes('\r\n');
+    const fileLines = content.split(/\r?\n/);
+    const oldLines = [];
+    const newLines = [];
+    for (const l of hunkLines) {
+        if (l.startsWith('@@'))
+            continue;
+        if (l.startsWith('+')) {
+            newLines.push(l.slice(1));
+        }
+        else if (l.startsWith('-')) {
+            oldLines.push(l.slice(1));
+        }
+        else if (l.startsWith(' ')) {
+            oldLines.push(l.slice(1));
+            newLines.push(l.slice(1));
+        }
+        else if (l === '') {
+            oldLines.push('');
+            newLines.push('');
+        }
+        else {
+            oldLines.push(l);
+            newLines.push(l);
+        }
+    }
+    if (!oldLines.length) {
+        return { ok: false, error: 'Hunk has no context or removed lines to anchor on.' };
+    }
+    const norm = (s, mode) => {
+        if (mode === 'exact')
+            return s;
+        if (mode === 'trim')
+            return s.replace(/[ \t]+$/, '');
+        return s.replace(/\s+/g, '');
+    };
+    for (const mode of ['exact', 'trim', 'ws']) {
+        const anchor = oldLines.map((l) => norm(l, mode));
+        for (let i = 0; i + anchor.length <= fileLines.length; i++) {
+            let match = true;
+            for (let j = 0; j < anchor.length; j++) {
+                if (norm(fileLines[i + j], mode) !== anchor[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (!match)
+                continue;
+            const before = fileLines.slice(0, i);
+            const after = fileLines.slice(i + anchor.length);
+            const joined = [...before, ...newLines, ...after].join(hasCRLF ? '\r\n' : NL);
+            return { ok: true, content: joined };
+        }
+    }
+    return {
+        ok: false,
+        error: 'Context not found in the file (hunk did not match): ' +
+            oldLines[0].slice(0, 60),
+    };
+}
+// ---------- factory ----------
+export function createExtraTools(workdir, { undo } = {}) {
+    const root = path.resolve(workdir);
+    const safe = (p) => {
+        const resolved = path.resolve(root, p);
+        const rel = path.relative(root, resolved);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) {
+            throw new Error('Access outside the working directory is forbidden: ' + p);
+        }
+        return resolved;
+    };
+    // Guard against missing/placeholder required args: a missing `path` becomes
+    // String(undefined) === "undefined" and would create a file literally named
+    // "undefined" in the working directory.
+    const req = (v, name) => {
+        if (v === undefined || v === null) {
+            throw new Error(`Missing required argument: ${name}`);
+        }
+        const s = String(v);
+        if (s === '' || s === 'undefined' || s === 'null') {
+            throw new Error(`Invalid required argument ${name}: ${JSON.stringify(v)}`);
+        }
+        return s;
+    };
+    return [
+        {
+            name: 'LS',
+            description: 'List the contents of a directory (files and subfolders). ' +
+                'path defaults to the working directory. Folders are marked with a slash.',
+            parameters: { path: 'string?', ignore: 'string?' },
+            fn: async ({ path: p, ignore }) => {
+                const target = p ? safe(req(p, 'path')) : root;
+                const stat = await fs.stat(target).catch(() => null);
+                if (!stat)
+                    throw new Error('No such directory: ' + p);
+                if (!stat.isDirectory())
+                    throw new Error('Not a directory: ' + p);
+                const ignoreList = (ignore ? String(ignore) : '')
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                const entries = await fs.readdir(target, { withFileTypes: true });
+                const rows = [];
+                for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                    if (ignoreList.includes(e.name))
+                        continue;
+                    if (e.name === 'node_modules' || e.name === '.git') {
+                        rows.push(e.name + '/ (skipped)');
+                        continue;
+                    }
+                    if (e.isDirectory()) {
+                        rows.push(e.name + '/');
+                    }
+                    else {
+                        const full = path.join(target, e.name);
+                        const st = await fs.stat(full).catch(() => null);
+                        rows.push(e.name + (st ? `  (${st.size} bytes)` : ''));
+                    }
+                }
+                return rows.length ? rows.join(NL) : '(empty)';
+            },
+        },
+        {
+            name: 'MultiEdit',
+            description: 'Several targeted edits to ONE file in a single call. edits is an array of ' +
+                '{old_string, new_string, replace_all?}. Edits are applied ' +
+                'in order; if any is not found — none are applied. ' +
+                'For a single edit use Edit.',
+            parameters: {
+                path: 'string',
+                edits: 'array',
+                edits_base64: 'string?',
+            },
+            fn: async ({ path: p, edits, edits_base64 }) => {
+                const file = safe(req(p, 'path'));
+                let list;
+                if (typeof edits_base64 === 'string' && edits_base64.length) {
+                    list = JSON.parse(Buffer.from(edits_base64, 'base64').toString('utf-8'));
+                }
+                else if (Array.isArray(edits)) {
+                    list = edits;
+                }
+                else {
+                    throw new Error('edits must be an array of edits.');
+                }
+                if (!list.length)
+                    throw new Error('edits is empty — nothing to apply.');
+                let content = await fs.readFile(file, 'utf-8');
+                for (let i = 0; i < list.length; i++) {
+                    const e = list[i];
+                    const oldStr = String(e.old_string ?? '');
+                    const newStr = String(e.new_string ?? '');
+                    if (oldStr === '') {
+                        throw new Error(`edits[${i}]: old_string is empty.`);
+                    }
+                    const occurrences = content.split(oldStr).length - 1;
+                    if (occurrences === 0) {
+                        throw new Error(`edits[${i}]: string not found: "${oldStr.slice(0, 60)}..."`);
+                    }
+                    if (occurrences > 1 && !e.replace_all) {
+                        throw new Error(`edits[${i}]: string occurs ${occurrences} times. ` +
+                            'Make old_string more specific or pass replace_all=true.');
+                    }
+                    content = e.replace_all
+                        ? content.split(oldStr).join(newStr)
+                        : content.replace(oldStr, newStr);
+                }
+                if (undo)
+                    await undo.backup(file);
+                await fs.writeFile(file, content, 'utf-8');
+                return `Edited (${list.length} edits): ${p}`;
+            },
+        },
+        {
+            name: 'TodoWrite',
+            description: 'Create/update the session task list. Accepts todos — an array of ' +
+                '{content, status}, where status: pending | in_progress | completed. ' +
+                'Helps track multi-step tasks. Replaces the whole list.',
+            parameters: { todos: 'array', todos_base64: 'string?' },
+            fn: async ({ todos, todos_base64 }) => {
+                let list;
+                if (typeof todos_base64 === 'string' && todos_base64.length) {
+                    list = JSON.parse(Buffer.from(todos_base64, 'base64').toString('utf-8'));
+                }
+                else if (Array.isArray(todos)) {
+                    list = todos;
+                }
+                else {
+                    throw new Error('todos must be an array.');
+                }
+                const items = normalizeTodos(list);
+                todoList.length = 0;
+                todoList.push(...items);
+                return renderTodos(todoList);
+            },
+        },
+        {
+            name: 'ApplyPatch',
+            description: 'Apply a patch to several files in a single call (Codex format). ' +
+                'Body: "*** Begin Patch", operations "*** Add File: <path>" (lines with +), ' +
+                '"*** Update File: <path>" (context with a space, removals with -, additions ' +
+                'with +, @@ anchors optional), "*** Delete File: <path>", then ' +
+                '"*** End Patch". Paths must be relative and inside the project.',
+            parameters: { patch: 'string?', patch_base64: 'string?' },
+            fn: async ({ patch, patch_base64 }) => {
+                const text = decodeContent(patch, patch_base64);
+                const { ops, error } = parsePatch(text);
+                if (error)
+                    throw new Error(error);
+                // Stage every change first, then write.
+                const writes = [];
+                for (const op of ops) {
+                    const file = safe(op.file);
+                    if (op.op === 'delete') {
+                        writes.push({ file, content: null });
+                        continue;
+                    }
+                    if (op.op === 'add') {
+                        const body = op.lines
+                            .filter((l) => l.startsWith('+'))
+                            .map((l) => l.slice(1))
+                            .join(NL);
+                        writes.push({ file, content: body + NL });
+                        continue;
+                    }
+                    let current;
+                    try {
+                        current = await fs.readFile(file, 'utf-8');
+                    }
+                    catch {
+                        throw new Error('Update File: no such file ' + op.file);
+                    }
+                    const res = applyUpdateHunk(current, op.lines);
+                    if (!res.ok) {
+                        throw new Error('Update File ' + op.file + ': ' + res.error);
+                    }
+                    writes.push({ file, content: res.content });
+                }
+                const summary = [];
+                for (const w of writes) {
+                    if (undo)
+                        await undo.backup(w.file);
+                    if (w.content === null) {
+                        await fs.unlink(w.file).catch(() => { });
+                        summary.push('deleted ' + path.relative(root, w.file));
+                    }
+                    else {
+                        await fs.mkdir(path.dirname(w.file), { recursive: true });
+                        await fs.writeFile(w.file, w.content, 'utf-8');
+                        summary.push('written ' + path.relative(root, w.file));
+                    }
+                }
+                return 'Patch applied:' + NL + summary.join(NL);
+            },
+        },
+    ];
+}

package/dist/gitTools.js

@@ -18,16 +18,16 @@ export function runGit(cmd, cwd, timeout = 15_000) {
             const errStr = (stderr || '').toString();
             if (!err) {
                 const combined = (out + errStr).trim();
-                resolve(combined || '(команда выполнена, вывода нет)');
+                resolve(combined || '(command produced no output)');
                 return;
             }
             const parts = [];
             if (err.killed)
-                parts.push(`⏱ Таймаут ${timeout}ms`);
+                parts.push(`⏱ Timeout ${timeout}ms`);
             else if (err.code !== undefined && err.code !== null)
                 parts.push(`Exit code: ${err.code}`);
             else
-                parts.push(`Ошибка: ${err.message}`);
+                parts.push(`Error: ${err.message}`);
             if (out.trim())
                 parts.push(out.trim());
             if (errStr.trim())
@@ -114,7 +114,7 @@ export function createGitTools(workdir) {
     return [
         {
             name: 'GitStatus',
-            description: 'Показать git status рабочей директории. Возвращает ошибку, если это не git-репозиторий.',
+            description: 'Show the git status of the working directory. Returns an error if this is not a git repository.',
             parameters: {},
             fn: async () => {
                 const err = await ensureRepo();
@@ -125,7 +125,7 @@ export function createGitTools(workdir) {
         },
         {
             name: 'GitDiff',
-            description: 'Показать git diff. По умолчанию незастейдженные изменения. Можно ограничить path и указать staged=true.',
+            description: 'Show git diff. By default unstaged changes. Can be limited with path and staged=true.',
             parameters: { path: 'string?', staged: 'boolean?' },
             fn: async ({ path: p, staged }) => {
                 const err = await ensureRepo();
@@ -141,7 +141,7 @@ export function createGitTools(workdir) {
         },
         {
             name: 'GitLog',
-            description: 'Показать последние N коммитов (по умолчанию 10).',
+            description: 'Show the last N commits (default 10).',
             parameters: { count: 'number?' },
             fn: async ({ count }) => {
                 const err = await ensureRepo();
@@ -152,7 +152,7 @@ export function createGitTools(workdir) {
         },
         {
             name: 'GitAdd',
-            description: 'Добавить файлы в индекс. Если paths не задан — git add -A (всё).',
+            description: 'Stage files. If paths is not given — git add -A (everything).',
             parameters: { paths: 'string?' },
             fn: async ({ paths }) => {
                 const err = await ensureRepo();
@@ -165,7 +165,7 @@ export function createGitTools(workdir) {
         },
         {
             name: 'GitCommit',
-            description: 'Закоммитить застейдженное (если ничего не застейджено — сначала git add -A). Не пушит.',
+            description: 'Commit staged changes (if nothing is staged — git add -A first). Does not push.',
             parameters: { message: 'string' },
             fn: async ({ message }) => {
                 const err = await ensureRepo();
@@ -173,14 +173,14 @@ export function createGitTools(workdir) {
                     return err;
                 const msg = String(message || '');
                 if (!msg.trim()) {
-                    return 'Ошибка: message пустой.';
+                    return 'Error: message is empty.';
                 }
                 // We stage everything only if the index is empty (as the description promises).
                 const staged = await runGit('git diff --cached --name-only', workdir, 10_000);
                 const hasStaged = !/^\s*/.test(staged) &&
-                    staged.trim() !== '(команда выполнена, вывода нет)';
+                    staged.trim() !== '(command produced no output)';
                 const addResult = hasStaged
-                    ? '(индекс уже не пуст — add -A пропущен)'
+                    ? '(index is not empty — add -A skipped)'
                     : await runGit('git add -A', workdir, 20_000);
                 const fs = await import('fs/promises');
                 const path = await import('path');
@@ -198,7 +198,7 @@ export function createGitTools(workdir) {
         },
         {
             name: 'GitPush',
-            description: 'Запушить ветку в origin. Требует настроенных креденшелов (SSH или Windows Credential Manager).',
+            description: 'Push a branch to origin. Requires configured credentials (SSH or Windows Credential Manager).',
             parameters: { branch: 'string?', setUpstream: 'boolean?' },
             fn: async ({ branch, setUpstream }) => {
                 const err = await ensureRepo();
@@ -208,7 +208,7 @@ export function createGitTools(workdir) {
                     ? String(branch).trim()
                     : (await runGit('git branch --show-current', workdir, 5000)).trim();
                 if (!b)
-                    return 'Ошибка: не удалось определить ветку для push.';
+                    return 'Error: could not determine the branch to push.';
                 const flag = setUpstream ? '-u ' : '';
                 const target = quoteArgs(b);
                 return runGit(`git push ${flag}origin ${target}`, workdir, 120_000);

package/dist/i18n.js

@@ -78,6 +78,18 @@ const CATALOG = {
     'help.cmd.undo': { ru: '/undo                    откатить последнюю запись/правку', en: '/undo                    revert the last write/edit' },
     'help.cmd.undo_list': { ru: '/undo-list               список того, что можно откатить', en: '/undo-list               list revertable changes' },
     'help.cmd.transcript': { ru: '/transcript              путь к файлу транскрипта', en: '/transcript              transcript file path' },
+    'help.cmd.diff': { ru: '/diff [--staged] показать git diff', en: '/diff [--staged] show working tree git diff' },
+    'help.cmd.cost': { ru: '/cost статистика сессии', en: '/cost session stats' },
+    'help.cmd.export': { ru: '/export [file] выгрузить сессию в Markdown', en: '/export [file] export the session to Markdown' },
+    'help.cmd.doctor': { ru: '/doctor диагностика установки и конфига', en: '/doctor diagnose install and config' },
+    'help.cmd.permissions': { ru: '/permissions настройки подтверждений', en: '/permissions confirmation settings' },
+    'help.cmd.add_dir': { ru: '/add-dir <path> проверить директорию', en: '/add-dir <path> validate a directory' },
+    'help.cmd.review': { ru: '/review [focus] ревью незакоммиченных изменений', en: '/review [focus] review uncommitted changes' },
+    'diff.not_repo': { ru: 'Не git-репозиторий.', en: 'Not a git repository.' },
+    'export.done': { ru: 'Сессия выгружена: {v}', en: 'Session exported: {v}' },
+    'export.outside': { ru: 'Путь вне рабочей директории.', en: 'Path is outside the working directory.' },
+    'adddir.not_dir': { ru: 'Нет такой директории: {v}', en: 'No such directory: {v}' },
+    'adddir.note': { ru: 'Директория существует: {v}. Песочница фиксируется при запуске.', en: 'Directory exists: {v}. The sandbox is fixed at startup.' },
     'help.cmd.config': { ru: '/config                  настройки: показать и изменить', en: '/config                  settings: view and edit' },
     'help.cmd.lang': { ru: '/config lang <ru|en>     сменить язык интерфейса и агента', en: '/config lang <ru|en>     switch UI and agent language' },
     'help.cmd.debug_dom': { ru: '/debug-dom               сохранить HTML страницы (для отладки)', en: '/debug-dom               dump page HTML (debug)' },

package/dist/index.js

@@ -15,6 +15,7 @@ import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n
 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, } from './commands.js';
 import { closeWeb } from './web.js';
 import { saveSession, loadLastSession, listSessions, sessionsDir, } from './sessions.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -93,6 +94,7 @@ const SRC_EXT = /[.]ts$/.test(new URL(import.meta.url).pathname) ? '.ts' : '.js'
 const RELOADABLE = [
     'mcp',
     'tools',
+    'extraTools',
     'agent-loop',
     'system-prompt',
     'gitTools',
@@ -217,6 +219,13 @@ ${theme.bold(t('help.commands'))}
   ${t('help.cmd.undo')}
   ${t('help.cmd.undo_list')}
   ${t('help.cmd.transcript')}
+ ${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.config')}
   ${t('help.cmd.lang')}
   ${t('help.cmd.debug_dom')}
@@ -265,6 +274,13 @@ const SLASH_COMMANDS = [
     { name: '/undo', key: 'help.cmd.undo' },
     { name: '/undo-list', key: 'help.cmd.undo_list' },
     { name: '/transcript', key: 'help.cmd.transcript' },
+    { name: '/diff', key: 'help.cmd.diff' },
+    { 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: '/config', key: 'help.cmd.config' },
     { name: '/skills', key: 'help.cmd.skills' },
     { name: '/memory', key: 'help.cmd.memory' },
@@ -825,7 +841,7 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
             // 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('Достигнут лимит итераций') ||
+                (outcome.startsWith('Iteration limit reached') ||
                     outcome.startsWith('ask() watchdog'))) {
                 ui.warning(outcome);
                 transcript?.log('agent_no_answer', { outcome });
@@ -1985,6 +2001,150 @@ async function main() {
             console.log(theme.system(transcript.file || t('common.off')));
             continue;
         }
+        if (lower === '/diff' || lower.startsWith('/diff ')) {
+            const staged = lower.indexOf("--staged") !== -1;
+            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(diffGitArgs(staged), currentWorkdir, 20_000);
+            console.log(theme.system(formatDiff(out, { maxLines: 400 })));
+            continue;
+        }
+        if (lower === '/cost' || lower === '/usage') {
+            let stats = summarizeTranscript([]);
+            if (transcript.file) {
+                try {
+                    const body = await fs.readFile(transcript.file, 'utf-8');
+                    stats = summarizeTranscript(parseTranscript(body));
+                }
+                catch {
+                    // best-effort
+                }
+            }
+            console.log(theme.system(renderCost(stats, transcript.file)));
+            continue;
+        }
+        if (lower === '/export' || lower.startsWith('/export ')) {
+            const arg = trimmed.slice('/export'.length).trim();
+            const target = arg
+                ? path.resolve(currentWorkdir, arg)
+                : defaultExportPath(currentWorkdir);
+            const rel = path.relative(sandboxRoot, target);
+            if (rel.startsWith('..') || path.isAbsolute(rel)) {
+                console.error(theme.error(t('export.outside')));
+                continue;
+            }
+            let entries = [];
+            if (transcript.file) {
+                try {
+                    entries = parseTranscript(await fs.readFile(transcript.file, 'utf-8'));
+                }
+                catch {
+                    entries = [];
+                }
+            }
+            const md = formatExport(entries, {
+                chatId: currentChatId,
+                workdir: currentWorkdir,
+            });
+            await fs.writeFile(target, md, 'utf-8');
+            console.log(theme.assistant(t('export.done', { v: target })));
+            continue;
+        }
+        if (lower === '/doctor') {
+            const { runGit } = await import('./gitTools.js');
+            let gitOk = false;
+            let gitBranch = null;
+            try {
+                const probe = await runGit('git rev-parse --is-inside-work-tree', currentWorkdir, 5000);
+                gitOk = probe.trim() === 'true';
+                if (gitOk) {
+                    gitBranch = (await runGit('git branch --show-current', currentWorkdir, 5000)).trim();
+                }
+            }
+            catch {
+                gitOk = false;
+            }
+            let clipboardTool = null;
+            try {
+                clipboardTool = hasClipboardTool() ? 'available' : null;
+            }
+            catch {
+                clipboardTool = null;
+            }
+            const mcpStatus = mcpPool
+                ? mcpPool.status()
+                : { servers: [], toolCount: 0 };
+            console.log(theme.system(renderDoctor({
+                nodeVersion: process.version,
+                platform: process.platform,
+                workdir: currentWorkdir,
+                gitOk,
+                gitBranch,
+                configOk: true,
+                browserChannel: config.browserChannel,
+                clipboardTool,
+                mcpServers: mcpStatus.servers.length,
+                mcpTools: mcpStatus.toolCount,
+                transcriptOk: !!transcript.file,
+            })));
+            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,
+            })));
+            continue;
+        }
+        if (lower === '/add-dir' || lower.startsWith('/add-dir ')) {
+            const arg = trimmed.slice('/add-dir'.length).trim();
+            const res = resolveExtraDir(arg, currentWorkdir);
+            if ('error' in res) {
+                console.error(theme.warn(res.error));
+                continue;
+            }
+            const stat = await fs.stat(res.path).catch(() => null);
+            if (!stat || !stat.isDirectory()) {
+                console.error(theme.error(t('adddir.not_dir', { v: res.path })));
+                continue;
+            }
+            console.log(theme.system(t('adddir.note', { v: res.path })));
+            continue;
+        }
+        if (lower === '/review' || lower.startsWith('/review ')) {
+            const rest = trimmed.slice('/review'.length).trim();
+            const staged = rest.indexOf("--staged") !== -1;
+            const focus = rest.replace(/--staged/g, '').trim();
+            const reviewTask = buildReviewPrompt(focus, staged);
+            const reviewTools = mod.createTools(currentWorkdir, { undo });
+            if (editor)
+                editor.busy = true;
+            try {
+                await runTask(browser, reviewTools, reviewTask, currentWorkdir, {
+                    transcript,
+                    freshChat: false,
+                    sendSystemPrompt: false,
+                    ui: editor || null,
+                    onChatReady: (chatId) => {
+                        if (chatId) {
+                            currentChatId = chatId;
+                            saveLastChat(chatId, currentWorkdir);
+                        }
+                    },
+                });
+            }
+            finally {
+                if (editor)
+                    editor.busy = false;
+            }
+            continue;
+        }
         if (lower === '/undo') {
             const result = await undo.undoLast();
             if (result.ok && result.record) {