zames_pro 2.89.0 → 2.90.1

package/dist/index.js

@@ -2,16 +2,28 @@
 import './color.js';
 import path from 'path';
 import fs from 'fs/promises';
-import { readFileSync, statSync } from 'fs';
+import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme, applyTheme, themeColors, themeNames, currentThemeName, isThemeName, } from './theme.js';
 import { setInputBorder } from './tui/ui-colors.js';
+import { nonReloadableSources, diffChanged } from './dev-watch.js';
+import { noteSwallowed, swallowedReport } from './swallow.js';
+import { pickFallbackProvider } from './provider-fallback.js';
+import { SYSTEM_PROMPT_BUDGET_BYTES } from './prompt-budget.js';
+import { resolvePasswordStore } from './password-store.js';
+import { dispatchCommand } from './command-registry.js';
+import { createInfoCommands } from './info-commands.js';
+import { createSessionCommands } from './session-commands.js';
+import { createTreeCommands } from './tree-commands.js';
+import { createSchedulerCommands } from './scheduler-commands.js';
+import { createDevCommands } from './dev-commands.js';
+import { shouldRunWizard, chooseLanguage, chooseProvider, providerNote, } from './first-run.js';
 import { DeepSeekBrowser, headlessUACacheReady } from './browser.js';
 import { QwenBrowser } from './qwen-browser.js';
 import { GlmBrowser } from './glm-browser.js';
 import { authMarkerHas } from './browser-pure.js';
 import { canShowWindow } from './browser-login.js';
-import { isProviderId, asProviderId, providerChatUrlPrefix, providerLabel, providerHasModelPicker, providerNeedsVisibleBrowser, providerConfigSection, PROVIDER_IDS, } from './providers.js';
+import { isProviderId, asProviderId, providerGuestAllowed, providerChatUrlPrefix, providerLabel, providerHasModelPicker, providerNeedsVisibleBrowser, providerConfigSection, PROVIDER_IDS, } from './providers.js';
 import { createTools, mergeTools, filterToolsForReadOnly, filterToolsByAllowList, } from './tools.js';
 import { createTodoStore, getTodos, setTodos, resetTodos, renderTodos, } from './extraTools.js';
 import { runAgentLoop } from './agent-loop.js';
@@ -26,7 +38,7 @@ import { runConfigMenu } from './config-menu.js';
 import { runConfigMenuInk } from './tui/run-config-menu.js';
 import { formatConfigList } from './config-commands.js';
 import { handleConfigCommand as runConfigCommand } from './config-command.js';
-import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n.js';
+import { translate, normalizeLocale, localeDisplayName, isLocale, DEFAULT_LOCALE, } from './i18n.js';
 import { Transcript } from './transcript.js';
 import { UndoStore, undoDateLabel } from './undo.js';
 import { CheckpointStore, pickRecord as pickCheckpoint, isFullStampSelector, } from './checkpoint.js';
@@ -131,7 +143,7 @@ setInputBorder(config.ui?.inputBorder);
 // Current interface/agent language. Changed by the /config lang <ru|en> command.
 let currentLocale = isLocale(config.ui?.locale)
     ? config.ui.locale
-    : 'ru';
+    : DEFAULT_LOCALE;
 // Translation: reads currentLocale at call time, so a language change takes
 // effect immediately, without a restart (for lines printed afterwards).
 const t = (key, params) => translate(currentLocale)(key, params);
@@ -388,37 +400,37 @@ async function autoReload() {
         for (const e of errors)
             console.error(theme.warn('  ' + e));
     }
-    warnIfBrowserChanged();
+    warnIfNonReloadableChanged();
 }
-// `browser.ts` is NOT in RELOADABLE: it is imported statically (once) and the
-// live DeepSeekBrowser instance owns the Playwright context/page/timers, so a
-// hot swap is unsafe. In dev mode (`npm run dev` = tsx over src/) the operator
-// therefore keeps running the OLD browser code after editing it, and a fix
-// "does not work" until the process is restarted. We detect the mtime change
-// and print a ONE-TIME hint so this is never a silent trap again.
-let browserMtime = 0;
-let browserChangedWarned = false;
-function browserSourcePath() {
-    // In dev the running file is src/index.ts; in the built dist — dist/index.js
-    // with the sources next to it (../src). Either way we look for browser.ts.
-    const srcDir = /[.]ts$/.test(new URL(import.meta.url).pathname)
+// Modules in RELOADABLE are hot-swapped by /reload; EVERYTHING else in src/
+// keeps running the copy loaded at startup. In dev mode (`npm run dev` = tsx
+// over src/) an edit to such a file therefore "does not work" until the
+// process is restarted - the operator sees the OLD code with no signal. We
+// watch the whole non-reloadable set (computed from the tree, not hardcoded)
+// and print ONE warning listing the changed files.
+const nonReloadableMtimes = new Map();
+let nonReloadableWarned = false;
+function srcDirPath() {
+    // In dev the running file is src/index.ts; in the built dist - dist/index.js
+    // with the sources next to it (../src).
+    return /[.]ts$/.test(new URL(import.meta.url).pathname)
         ? path.dirname(fileURLToPath(import.meta.url))
         : path.join(__dirname, '..', 'src');
-    return path.join(srcDir, 'browser.ts');
 }
-function warnIfBrowserChanged() {
-    if (!devMode)
+function warnIfNonReloadableChanged() {
+    if (!devMode || nonReloadableWarned)
         return;
     try {
-        const p = browserSourcePath();
-        const st = statSync(p);
-        if (!browserMtime) {
-            browserMtime = st.mtimeMs;
+        const files = nonReloadableSources(srcDirPath());
+        const changed = diffChanged(files, nonReloadableMtimes);
+        if (changed.length === 0)
             return;
-        }
-        if (st.mtimeMs !== browserMtime && !browserChangedWarned) {
-            browserChangedWarned = true;
-            console.error(theme.warn(t('reload.browser_restart')));
+        // The first snapshot only records the state; it must not warn.
+        if (nonReloadableMtimes.size === files.length && changed.length > 0) {
+            nonReloadableWarned = true;
+            console.error(theme.warn(t('reload.non_reloadable_restart', {
+                files: changed.map((f) => path.basename(f)).join(', '),
+            })));
         }
     }
     catch { }
@@ -1099,9 +1111,87 @@ async function main() {
     // with a clear message instead of retrying into a dead chat.
     let contextLimitRecovery = null;
     const onContextLimit = () => contextLimitRecovery ? contextLimitRecovery() : Promise.resolve(false);
+    /**
+     * N19: the FIRST-RUN wizard. A brand-new install (no `~/.zames/config.json`)
+     * otherwise lands straight in a chat with no explanation of the language,
+     * the backend choice or why DeepSeek needs a real sign-in. It runs ONCE,
+     * BEFORE the input loop (inside the loop it blocked the very first prompt),
+     * never in a scripted / non-TTY session, and Esc accepts the defaults.
+     */
+    const runFirstRunWizard = async () => {
+        if (!shouldRunWizard({
+            configExists: (() => {
+                try {
+                    return readFileSync(CONFIG_PATHS.HOME_CONFIG, 'utf-8').length > 0;
+                }
+                catch {
+                    return false;
+                }
+            })(),
+            isTTY: !!(process.stdin.isTTY && process.stdout.isTTY),
+            nonInteractiveLogin: process.env.ZAMES_NONINTERACTIVE_LOGIN === '1',
+            oneShot: !!getArg('--task', null),
+        })) {
+            return;
+        }
+        try {
+            console.log(theme.system(t('wizard.welcome')));
+            // A raw line reader, NOT askOperatorConfirm: that one is a y/N dialog
+            // (Enter = "no"), which is wrong here — the DEFAULT for a fresh install is
+            // English, so an empty answer must keep it. Read a word and normalize.
+            const answer = await promptOnce(t('wizard.language') + ' ');
+            const wantRu = /^(ru|russian|\u0440\u0443\u0441)/i.test(String(answer || '').trim());
+            const locale = wantRu ? 'ru' : 'en';
+            config.ui.locale = locale;
+            currentLocale = locale;
+            chooseLanguage({ step: 0, locale: null, provider: null, needsLogin: false }, locale);
+            // A provider id is free-form, not yes/no: read it with the raw prompt
+            // (the same one the sign-in uses). An empty answer keeps the default.
+            const rawProvider = await promptOnce(theme.prompt(t('wizard.provider')));
+            const picked = isProviderId(String(rawProvider || '').trim())
+                ? asProviderId(String(rawProvider || '').trim())
+                : asProviderId(config.provider);
+            chooseProvider({ step: 1, locale, provider: null, needsLogin: false }, picked);
+            config.provider = picked;
+            setProviderEnabledFlag(picked);
+            console.log(theme.dim(providerNote(picked)));
+            try {
+                writeConfigValue('home', 'provider', picked);
+                writeConfigValue('home', 'ui.locale', locale);
+            }
+            catch (e) {
+                noteSwallowed('wizard_config_write', e, debug);
+            }
+            console.log(theme.system(t('wizard.hint')));
+        }
+        catch (e) {
+            // Esc / a closed stdin: accept the defaults, never block the first run.
+            noteSwallowed('first_run_wizard', e, debug);
+            console.log(theme.dim(t('wizard.skipped')));
+        }
+    };
+    // N19: the wizard runs ONCE here, BEFORE the input loop and before the
+    // browser is launched (a provider picked here must be the one that starts).
+    // It used to be inserted INSIDE the loop, where it held the first prompt:
+    // the terminal looked ready while a modal waited, and every command hung.
+    await runFirstRunWizard();
     let browser = createProviderBrowser(asProviderId(config.provider), onContextLimit);
-    const bootSpinner = mod.createSpinner(currentLocale);
-    bootSpinner.thinking();
+    // NO ora spinner while the TUI is going to own the terminal.
+    //
+    // ora writes to stderr and erases/redraws ITS OWN line; Ink (the TUI)
+    // repaints the WHOLE frame through log-update on the same terminal. The two
+    // invalidate each other every tick: measured 53 MB / ~5.9 M `\e[1A\e[0K`
+    // sequences in 60 s of `waitForLogin` (the operator saw a caret that "does
+    // not work" — the screen was being repainted ~100k times a second). The TUI
+    // status bar already animates that phase, so the ora spinner is only for the
+    // non-TUI path. `bootSpinner` stays a no-op stop() object so the error path
+    // below needs no branching.
+    const tuiWillRun = !!(process.stdin.isTTY && process.stdout.isTTY) && !!config.ui.tui;
+    const bootSpinner = tuiWillRun
+        ? { thinking() { }, stop() { }, setLocale() { } }
+        : mod.createSpinner(currentLocale);
+    if (!tuiWillRun)
+        bootSpinner.thinking();
     try {
         await browser.launch();
         bootSpinner.stop();
@@ -1139,64 +1229,6 @@ async function main() {
         warnUiHealth(await browser.probeUiHealth());
     }
     catch { }
-    // One-shot mode
-    if (task) {
-        const baseTools = mod.createTools(currentWorkdir, {
-            undo,
-            readOnly: planMode,
-        });
-        const tools = mergeTools(baseTools, mcpPool?.tools, planMode);
-        let freshChat = true;
-        let sendSystemPrompt = true;
-        // By default we start a new chat. To continue a previous session —
-        // explicitly: --chat <id> or --resume-last.
-        let resumeId = chatIdArg;
-        if (!resumeId && resumeLastFlag && !newChatFlag) {
-            const last = loadLastSession(currentWorkdir, config.provider);
-            if (last && last.id) {
-                resumeId = last.id;
-                console.log(theme.system(t('msg.resuming', { id: resumeId })));
-            }
-        }
-        if (resumeId) {
-            try {
-                console.log(theme.system(t('msg.opening_chat', { id: resumeId })));
-                await browser.openChat(resumeId);
-                freshChat = false;
-                sendSystemPrompt =
-                    resendPrompt || config.browser.resendPromptOnResume === true;
-                saveLastChat(resumeId, currentWorkdir);
-            }
-            catch (e) {
-                console.error(theme.error(t('msg.open_chat_error', { v: e.message })));
-            }
-        }
-        await autoReload();
-        const result = await mod.runTask(runTaskDeps(), browser, tools, task, currentWorkdir, {
-            transcript,
-            freshChat,
-            sendSystemPrompt,
-            selfImprovement: devMode,
-            onChatReady: (chatId) => {
-                if (chatId)
-                    saveLastChat(chatId, currentWorkdir);
-            },
-        });
-        // One-shot mode (--task) is documented for scripts/CI. A failed agent run
-        // used to exit 0, so the CI job stayed green; surface it as exit code 1.
-        if (!result.ok)
-            process.exitCode = 1;
-        await browser.close();
-        await mod.closeWeb().catch(() => { });
-        if (mcpPool)
-            await mcpPool.close().catch(() => { });
-        await transcript.close();
-        return;
-    }
-    if (providerNeedsVisibleBrowser(config.provider) &&
-        headlessFor(config.provider)) {
-        console.log(theme.warn(t('provider.needs_headed', { v: providerLabel(config.provider) })));
-    }
     console.log(theme.system(t('msg.interactive')));
     console.log(theme.system(t('msg.queue_hint')));
     console.log(theme.dim(t('msg.first_hint')));
@@ -1275,6 +1307,13 @@ async function main() {
     // /resume <n> handler that read it was removed).
     let lastChats;
     let currentChatId = null;
+    // The chat the NEXT send must land in. `currentChatId` is only a cache of
+    // "the id seen on the page"; after a page restart that cache is stale and
+    // the URL carries no id, so `freshChatNext` opened a NEW chat and the
+    // operator lost the resumed dialogue. This id is set on resume/restore and
+    // cleared when a genuinely fresh chat starts; the agent loop reads it via
+    // `browser.resumeChatId`.
+    let resumeChatId = null;
     // The last task the operator sent (used by /retry). Plain text only.
     let lastTaskText = '';
     let running = true;
@@ -1482,6 +1521,7 @@ async function main() {
             console.log(theme.system(t('msg.opening_chat', { id: resumeId })));
             await browser.openChat(resumeId);
             currentChatId = resumeId;
+            resumeChatId = resumeId;
             freshChatNext = false;
             sendSystemPromptNext = promptOnResume();
             saveLastChat(resumeId, currentWorkdir);
@@ -1823,6 +1863,22 @@ async function main() {
                     void handleGoal(text);
                     return;
                 }
+                // `/tasks` is READ-ONLY (it prints the TodoWrite checklist from the
+                // shared store): it must never be queued behind the running task, since
+                // the whole point is to see what the agent is doing RIGHT NOW.
+                if (/^\/tasks\s*$/i.test(text.trim())) {
+                    const items = getTodos(todoStore);
+                    if (!items.length) {
+                        ed.printAbove(theme.dim(t('tasks.empty')));
+                    }
+                    else {
+                        ed.printAbove(theme.system(t('tasks.title')));
+                        for (const line of renderTodos(items).split(NL).slice(1)) {
+                            ed.printAbove(theme.assistant(line));
+                        }
+                    }
+                    return;
+                }
             }
             const attachments = (items || []).map((a) => ({
                 path: a.path,
@@ -2331,6 +2387,7 @@ async function main() {
         try {
             await browser.openChat(pick.id);
             currentChatId = pick.id;
+            resumeChatId = pick.id;
             freshChatNext = false;
             sendSystemPromptNext = promptOnResume();
             saveLastChat(pick.id, currentWorkdir, pick.title);
@@ -2425,357 +2482,1165 @@ async function main() {
         await openResumedChat({ id: pick.id, title: pick.title || '' });
         return true;
     };
-    while (running) {
-        let input;
-        let inputAttachments = [];
-        // Set by `/goal <condition>` to fall through into a task turn with this
-        // text instead of returning to the prompt (Claude Code starts a turn the
-        // moment a goal is set). Reset every iteration because it is declared here.
-        let taskOverride = null;
+    /**
+     * N8: continue the task on an AUTHORIZED fallback provider after the active
+     * one exhausted its retries. Returns true when the backend really switched
+     * (the caller then resends the same prompt). A guest session or a dead
+     * marker is never used: the operator is told which provider can be
+     * authorized and how.
+     */
+    const fallbackToAuthorizedProvider = async (err) => {
+        const configured = (config.browser.fallbackProviders || []).filter(isProviderId);
+        if (!configured.length)
+            return false;
+        const active = asProviderId(config.provider);
+        const candidates = configured
+            .filter((id) => id !== active)
+            .map((id) => ({
+            id,
+            guestAllowed: providerGuestAllowed(id),
+            // Only a REAL session counts. The marker is the evidence; the switch
+            // below re-checks it with waitForLogin().
+            guestSession: !authMarkerExists(id),
+            authMarker: authMarkerExists(id) ? 'yes' : '',
+        }));
+        const decision = await pickFallbackProvider(active, candidates, async (id) => authMarkerExists(id), (raw, id) => raw === 'yes' && authMarkerExists(id));
+        if (!decision.provider) {
+            console.error(theme.warn(t('provider.fallback_none', {
+                from: providerLabel(active),
+                providers: (decision.authorizable.length
+                    ? decision.authorizable
+                    : configured)
+                    .map((id) => providerLabel(id))
+                    .join(', ') || '-',
+            })));
+            return false;
+        }
+        const target = decision.provider;
+        if (config.browser.fallbackMode !== 'auto') {
+            const ok = await askOperatorConfirm(editor, t('provider.fallback_ask', {
+                from: providerLabel(active),
+                to: providerLabel(target),
+            }), t, currentLocale);
+            if (!ok)
+                return false;
+        }
+        console.log(theme.system(t('provider.fallback_switch', {
+            from: providerLabel(active),
+            to: providerLabel(target),
+        })));
+        transcript.log('provider_fallback', {
+            from: active,
+            to: target,
+            error: err.message.slice(0, 200),
+        });
+        // A switch failure leaves the old browser in place, so returning false is
+        // safe. The handoff machinery is the SAME one /provider uses.
         try {
-            if (editor) {
-                editor.setPrompt(buildPrompt());
-                const msg = await takeInput();
-                input = msg ? msg.text : null;
-                inputAttachments = msg?.attachments || [];
+            config.provider = target;
+            setProviderEnabledFlag(target);
+            writeConfigValue('home', 'provider', target);
+            const nextBrowser = createProviderBrowser(target, onContextLimit);
+            await nextBrowser.waitForLogin();
+            const prev = browser;
+            browser = nextBrowser;
+            try {
+                await prev.close();
             }
-            else {
-                let tail;
-                // The non-TTY fallback prompt mirrors buildPrompt(): bare, no dir.
-                if (reviewMode) {
-                    tail =
-                        theme.dim('(') +
-                            theme.warn(t('prompt.review')) +
-                            theme.dim(':') +
-                            theme.dir(reviewMode.snapName) +
-                            theme.dim(') ');
-                }
-                input = await promptOnce(theme.prompt('❯ ') + tail);
+            catch (e) {
+                noteSwallowed('fallback_close_prev', e, debug);
             }
+            currentChatId = await browser.getCurrentChatId();
+            resumeChatId = null;
+            saveLastChat(currentChatId, currentWorkdir);
+            freshChatNext = true;
+            sendSystemPromptNext = true;
+            return true;
         }
-        catch {
-            break;
+        catch (e) {
+            console.error(theme.error(t('provider.switch_failed', {
+                v: providerLabel(target),
+                error: e.message,
+            })));
+            return false;
         }
-        const trimmed = (input || '').trim();
-        if (!trimmed)
-            continue;
-        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 = mod.commands.isDevOnlyCommand(lower);
-            if (devCmd) {
-                console.error(theme.warn(t('msg.dev_only', { v: devCmd })));
-                continue;
+    };
+    // One-shot mode
+    if (task) {
+        const baseTools = mod.createTools(currentWorkdir, {
+            undo,
+            readOnly: planMode,
+        });
+        const tools = mergeTools(baseTools, mcpPool?.tools, planMode);
+        let freshChat = true;
+        let sendSystemPrompt = true;
+        // By default we start a new chat. To continue a previous session —
+        // explicitly: --chat <id> or --resume-last.
+        let resumeId = chatIdArg;
+        if (!resumeId && resumeLastFlag && !newChatFlag) {
+            const last = loadLastSession(currentWorkdir, config.provider);
+            if (last && last.id) {
+                resumeId = last.id;
+                console.log(theme.system(t('msg.resuming', { id: resumeId })));
             }
         }
-        // `!command` — run a shell command directly, without asking the model
-        // (like Claude Code's bash mode). The same sandbox guard as the Bash tool
-        // applies, so a direct command cannot leave the project either.
-        if (trimmed.startsWith('!')) {
-            const cmd = trimmed.slice(1).trim();
-            if (!cmd) {
-                console.error(theme.warn(t('shell.empty')));
-                continue;
-            }
+        if (resumeId) {
             try {
-                assertCommandInsideRoot(currentWorkdir, cmd);
+                console.log(theme.system(t('msg.opening_chat', { id: resumeId })));
+                await browser.openChat(resumeId);
+                freshChat = false;
+                sendSystemPrompt =
+                    resendPrompt || config.browser.resendPromptOnResume === true;
+                saveLastChat(resumeId, currentWorkdir);
             }
             catch (e) {
-                console.error(theme.error(e.message));
-                continue;
-            }
-            transcript.log('shell_command', { command: cmd });
-            if (editor)
-                editor.lock(t('shell.running'));
-            try {
-                const out = await runShell(currentWorkdir, cmd);
-                console.log(theme.system(out));
-                transcript.log('shell_result', { command: cmd, result: out });
-            }
-            finally {
-                if (editor)
-                    editor.unlock();
+                console.error(theme.error(t('msg.open_chat_error', { v: e.message })));
             }
-            continue;
         }
-        if (lower === '/help' ||
-            lower === 'help' ||
-            lower.startsWith('/help ') ||
-            lower.startsWith('help ')) {
-            const topic = trimmed.replace(/^\/?help\s*/i, '').trim();
-            if (!topic) {
-                printHelp();
-            }
-            else {
-                // /help <command> — print the full description of ONE command instead
-                // of making the operator scroll the whole list.
-                const q = '/' + topic.replace(/^\//, '').toLowerCase();
-                const match = buildSlashCommands().filter((c) => c.name.toLowerCase() === q ||
-                    c.name.toLowerCase().startsWith(q + ' '));
-                if (!match.length) {
-                    console.error(theme.warn(t('help.no_topic', { v: topic })));
-                }
-                else {
-                    for (const c of match) {
-                        console.log(theme.assistant(c.name) + theme.dim('  ' + c.description));
-                    }
-                }
-            }
-            continue;
+        await autoReload();
+        const result = await mod.runTask(runTaskDeps(), browser, tools, task, currentWorkdir, {
+            transcript,
+            freshChat,
+            sendSystemPrompt,
+            selfImprovement: devMode,
+            onChatReady: (chatId) => {
+                if (chatId)
+                    saveLastChat(chatId, currentWorkdir);
+            },
+        });
+        // One-shot mode (--task) is documented for scripts/CI. A failed agent run
+        // used to exit 0, so the CI job stayed green; surface it as exit code 1.
+        if (!result.ok)
+            process.exitCode = 1;
+        await browser.close();
+        await mod.closeWeb().catch(() => { });
+        if (mcpPool)
+            await mcpPool.close().catch(() => { });
+        await transcript.close();
+        return;
+    }
+    if (providerNeedsVisibleBrowser(config.provider) &&
+        headlessFor(config.provider)) {
+        console.log(theme.warn(t('provider.needs_headed', { v: providerLabel(config.provider) })));
+    }
+    /** The live session state rendered by /status (and the registry handler). */
+    const statusSnapshot = () => {
+        const statusToggles = browser.getToggleStatesSync();
+        return {
+            workdir: currentWorkdir,
+            reviewMode: reviewMode ? reviewMode.snapName : null,
+            origDir: reviewMode ? reviewMode.originalWorkdir : null,
+            chatId: currentChatId,
+            freshNext: freshChatNext,
+            promptNext: sendSystemPromptNext,
+            lastChat: loadLastChat(currentWorkdir),
+            sessionsDir: sessionsDir(),
+            devMode,
+            maxIterations: currentMaxIter(),
+            headless,
+            debug,
+            deepThinking: statusToggles.deepThinking,
+            webSearch: statusToggles.webSearch,
+            undo: config.undo.enabled,
+            checkpoint: config.checkpoint.enabled,
+            transcriptFile: transcript.file,
+            goal: sessionGoal,
+            localeName: localeDisplayName(currentLocale),
+            mcpToolCount: mcpPool ? mcpPool.status().toolCount : null,
+            tokenUsage: browser.getLastTokenUsage(),
+        };
+    };
+    /** /sessions [filter]: the saved sessions (a pick list in the TUI). */
+    const sessionsCommand = async (filter) => {
+        // /sessions <query> filters by title or workdir (substring). Sorted by
+        // recency already (listSessions).
+        const all = filterSessions(listSessions(), filter);
+        console.log(theme.system(t('sessions.dir', { v: sessionsDir() })));
+        if (!all.length) {
+            console.log(theme.system(t('sessions.none')));
         }
-        if (['/new', '/clear', 'new'].includes(lower)) {
-            if (editor)
-                editor.lock(t('msg.input_locked'));
-            try {
-                await browser.newChat();
-                freshChatNext = false;
-                sendSystemPromptNext = true;
-                // A new chat starts a fresh checklist: keeping the old tasks would
-                // label them as "restored" in a chat that never saw them.
-                resetTodos(todoStore);
-                currentChatId = await browser.getCurrentChatId();
-                saveLastChat(currentChatId, currentWorkdir);
-                transcript.log('new_chat');
-                // Start the new chat on a clean screen (like /clear in a shell).
-                if (editor)
-                    editor.clearScreen();
-                console.log(theme.system(t('msg.new_chat')));
-                console.log(theme.system(t('msg.new_chat_ok') + String.fromCharCode(10)));
-            }
-            catch (e) {
-                console.error(theme.error(t('msg.new_chat_error', { v: e.message })), e.message);
-            }
-            finally {
-                if (editor)
-                    editor.unlock();
+        else {
+            // In the TUI, open a SELECT LIST and resume the chosen session
+            // directly (same behavior as /chats), instead of only listing ids.
+            const canPick = editor && 'isTui' in editor && config.ui.tui && !filter;
+            if (canPick && editor) {
+                const opened = await pickSessionInteractively(all);
+                if (opened)
+                    return;
             }
-            continue;
+            all.forEach((s, i) => {
+                const n = String(i + 1).padStart(2, ' ');
+                const mark = s.id === currentChatId ? theme.user(' *') : '';
+                const title = s.title ? `  ${s.title}` : '';
+                const wd = s.workdir ? theme.dim(`  [${dirLabel(s.workdir)}]`) : '';
+                const age = mod.commands.formatRelativeTime(s.updatedAt, t);
+                const ageText = age ? theme.dim('  ' + age) : '';
+                console.log(`  ${theme.user(n)}. ${s.id.slice(0, 8)}…${title}${wd}${ageText}${mark}`);
+            });
+            console.log(theme.system(t('sessions.restore_hint')));
         }
-        if (lower === '/self-review' || lower.startsWith('/self-review ')) {
-            const focus = trimmed.slice('/self-review'.length).trim();
-            // Remember where to return
-            const originalWorkdir = reviewMode
-                ? reviewMode.originalWorkdir
-                : currentWorkdir;
-            if (editor)
-                editor.lock(t('msg.input_locked'));
-            try {
-                const result = await mod.selfReview({
-                    browser,
-                    config,
-                    focus: focus || undefined,
-                    transcript,
-                    locale: currentLocale,
-                });
-                // Switch to review mode:
-                //  - working directory = snapshot
-                //  - we do NOT reset the chat — inside selfReview a fresh chat was
-                //    already created and the review prompt sent, we continue in it
-                reviewMode = {
-                    snapDir: result.snapDir,
-                    snapName: path.basename(result.snapDir),
-                    originalWorkdir,
-                };
-                currentWorkdir = result.snapDir;
-                freshChatNext = false;
-                sendSystemPromptNext = false;
-                currentChatId = await browser.getCurrentChatId();
-                saveLastChat(currentChatId, currentWorkdir);
-                console.log(theme.user(t('self.review_hint', { name: reviewMode.snapName })));
+    };
+    /** /last: reopen the last chat of this working directory. */
+    const lastCommand = async () => {
+        // Quick resume of the last chat for THIS working directory — otherwise
+        // finding it meant /chats (a network fetch) or copying the id.
+        const last = loadLastSession(currentWorkdir, config.provider);
+        if (!last || !last.id) {
+            console.error(theme.error(t('sessions.none_here')));
+            return;
+        }
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        try {
+            if (editor)
+                editor.clearScreen();
+            console.log(theme.system(t('msg.opening_chat', { id: last.id })));
+            await browser.openChat(last.id);
+            currentChatId = last.id;
+            resumeChatId = last.id;
+            freshChatNext = false;
+            sendSystemPromptNext = promptOnResume();
+            saveLastChat(last.id, currentWorkdir, last.title);
+            transcript.log('resume_chat', { id: last.id, title: last.title });
+            console.log(theme.assistant(t('msg.chat_opened')));
+            loadSessionTodos(last.id);
+            await printRestoredHistory(browser, editor, last.id);
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
+        }
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    /** /resume-id <id>: open a chat by its full id. */
+    const resumeIdCommand = async (raw) => {
+        const id = parseResumeId(raw);
+        if (!id) {
+            console.error(theme.error(t('sessions.resume_id_usage')));
+            return;
+        }
+        // A chat id only exists on the backend that created it, so opening a
+        // session saved by ANOTHER provider fails deep inside the browser with a
+        // confusing error. Refuse up front and name the right /provider command.
+        const refusal = resumeProviderRefusal(readSession(id), config.provider, t);
+        if (refusal) {
+            console.error(theme.error(refusal));
+            return;
+        }
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        try {
+            if (editor)
+                editor.clearScreen();
+            console.log(theme.system(t('msg.opening_chat', { id })));
+            await browser.openChat(id);
+            currentChatId = id;
+            resumeChatId = id;
+            freshChatNext = false;
+            sendSystemPromptNext = promptOnResume();
+            saveLastChat(id, currentWorkdir);
+            transcript.log('resume_chat', { id });
+            console.log(theme.assistant(t('msg.chat_opened')) +
+                theme.system(String.fromCharCode(10)));
+            loadSessionTodos(id);
+            await printRestoredHistory(browser, editor, id);
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
+        }
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    /** /chats [filter]: the backend chat list (internals hidden). */
+    const chatsCommand = async (filter) => {
+        const spin = editor || mod.createSpinner(currentLocale);
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        spin.thinking();
+        try {
+            const all = await browser.listChats(30);
+            // Hide subagent chats: they are real DeepSeek chats, but they are
+            // internal context-isolation artifacts whose report already lives in
+            // the parent chat, so resuming one is never what the operator wants.
+            // The scraper runs inside the page and cannot localize: a row without
+            // text comes back with an EMPTY title, so the label is applied HERE
+            // (one place, in the operator's language) instead of a hardcoded one.
+            lastChats = all
+                .filter((c) => !isInternalChat(c.id))
+                .map((c) => ({
+                ...c,
+                title: c.title && c.title.trim() ? c.title : t('chats.untitled'),
+            }));
+            spin.stop();
+            // An optional query filters by title (substring, case-insensitive),
+            // so a long chat list does not have to be scanned by eye.
+            const shown = filter
+                ? lastChats.filter((c) => c.title.toLowerCase().includes(filter))
+                : lastChats;
+            if (!shown.length) {
+                console.log(theme.system(t('chats.none_hint')));
             }
-            catch (e) {
-                console.error(theme.error(t('self.review_failed')), e.message);
-                if (debug)
-                    console.error(e.stack);
+            else {
+                // In the TUI, open a real SELECT LIST (like /model) instead of
+                // dumping text: pick a chat and it opens directly. The text path
+                // below stays for non-TTY / the legacy editor.
+                const canPick = editor && 'isTui' in editor && config.ui.tui && !filter;
+                if (canPick && editor) {
+                    const openChat = await pickChatInteractively(shown);
+                    if (openChat)
+                        return;
+                }
+                console.log(theme.system(t('chats.recent')));
+                // The number is the index in the FULL list (a filter only narrows
+                // the VIEW), and the full id in brackets is what /resume-id takes.
+                for (const c of shown) {
+                    const idx = lastChats.indexOf(c);
+                    const n = String(idx + 1).padStart(2, ' ');
+                    console.log(`  ${theme.user(n)}. ${c.title}  ${theme.system('(' + c.id.slice(0, 8) + '…)')}`);
+                }
+                console.log(theme.system(t('chats.use_resume')));
             }
-            finally {
+        }
+        catch (e) {
+            spin.stop();
+            console.error(theme.error(t('chats.fetch_error')), e.message);
+        }
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    /** /new and /clear: a fresh chat on a clean screen. */
+    const newChatCommand = async () => {
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        try {
+            await browser.newChat();
+            resumeChatId = null;
+            freshChatNext = false;
+            sendSystemPromptNext = true;
+            // A new chat starts a fresh checklist: keeping the old tasks would
+            // label them as "restored" in a chat that never saw them.
+            resetTodos(todoStore);
+            currentChatId = await browser.getCurrentChatId();
+            saveLastChat(currentChatId, currentWorkdir);
+            transcript.log('new_chat');
+            // Start the new chat on a clean screen (like /clear in a shell).
+            if (editor)
+                editor.clearScreen();
+            console.log(theme.system(t('msg.new_chat')));
+            console.log(theme.system(t('msg.new_chat_ok') + String.fromCharCode(10)));
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.new_chat_error', { v: e.message })), e.message);
+        }
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    /** /diff and /diffstat: the working-tree (or staged) diff. */
+    const diffCommand = async (staged, stat) => {
+        const { runGitArgs } = await import('./gitTools.js');
+        const probe = await runGitArgs(['rev-parse', '--is-inside-work-tree'], currentWorkdir, 5000);
+        if (probe.trim() !== 'true') {
+            console.error(theme.error(t('diff.not_repo')));
+            return;
+        }
+        const out = await runGitArgs(stat
+            ? mod.commands.diffStatGitArgs(staged)
+            : mod.commands.diffGitArgs(staged), currentWorkdir, 20_000);
+        console.log(theme.system(stat
+            ? mod.commands.formatDiffStat(out, { maxLines: 60 }, t)
+            : mod.commands.formatDiff(out, { maxLines: 400 }, t)));
+    };
+    /** /undo: revert the last file edit. */
+    const undoCommand = async () => {
+        const result = await undo.undoLast();
+        if (result.ok && result.record) {
+            console.log(theme.assistant(t('undo.reverted', { v: result.record.originalPath })) +
+                theme.system(result.record.existed ? t('undo.restored') : t('undo.deleted')));
+            transcript.log('undo', { path: result.record.originalPath });
+        }
+        else {
+            // undo.ts returns machine codes ('empty'/'disabled') — localize here so
+            // an English UI never shows a Russian reason.
+            const reasonKey = result.reason === 'empty'
+                ? 'undo.reason_empty'
+                : result.reason === 'disabled'
+                    ? 'undo.reason_disabled'
+                    : null;
+            const reason = reasonKey ? t(reasonKey) : String(result.reason ?? '');
+            console.error(theme.error(t('undo.failed', { v: reason })));
+        }
+    };
+    /** /undo-list (/history): the recent undo records. */
+    const undoListCommand = async () => {
+        const list = await undo.list(10);
+        if (!list.length) {
+            console.log(theme.system(t('undo.empty')));
+        }
+        else {
+            for (const r of list) {
+                const stamp = undoDateLabel(r.stamp);
+                const flag = r.existed ? t('undo.changed') : t('undo.created');
+                console.log(theme.system(`${stamp}  [${flag}]  ${r.originalPath}`));
+            }
+        }
+    };
+    /** /rewind-list (/checkpoints): the recent tree checkpoints. */
+    const rewindListCommand = async () => {
+        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 = undoDateLabel(r.stamp);
+                const label = r.label ? '  [' + t('rewind.label_backup') + ']' : '';
+                console.log(theme.system(`  ${i + 1}. ${stamp}  ${r.workdir}${label}`));
+            });
+        }
+    };
+    /** /rewind [n|stamp] [--yes]: restore the working tree from a checkpoint. */
+    const rewindCommand = async (selector, line) => {
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        try {
+            // The DISPLAY window is the newest 10, but a FULL stamp must resolve
+            // against the whole index (restore() searches all of it): an older
+            // checkpoint picked by its stamp used to report "/rewind failed", and a
+            // stamp sharing its first digits with a newer one could resolve to
+            // THAT wrong record.
+            const list = await checkpoints.list(10);
+            const all = isFullStampSelector(selector)
+                ? await checkpoints.list(Number.MAX_SAFE_INTEGER)
+                : list;
+            const target = pickCheckpoint(list, selector, all);
+            if (!target) {
+                console.error(theme.error(t('rewind.failed', { v: selector })));
+                return;
+            }
+            // 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.unlock();
+                    editor.pause();
+                try {
+                    answer = await promptOnce(theme.warn(t('rewind.confirm', { v: stamp })) + ' [y/N] ');
+                }
+                finally {
+                    if (editor)
+                        editor.resume();
+                }
+            }
+            else if (line.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')));
+                return;
+            }
+            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 })));
             }
-            continue;
         }
-        if (lower === '/self-fix' || lower.startsWith('/self-fix ')) {
-            const rest = trimmed.slice('/self-fix'.length).trim();
-            if (!rest) {
-                console.error(theme.error(t('self.fix_usage')));
-                continue;
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    /** /loop <interval> <task>. */
+    const loopCommand = (rest) => {
+        const sp = rest.indexOf(' ');
+        const intervalStr = sp === -1 ? rest : rest.slice(0, sp);
+        const taskStr = sp === -1 ? '' : rest.slice(sp + 1).trim();
+        const ms = parseInterval(intervalStr);
+        if (!ms && intervalStr) {
+            // Say WHY the job was not added. A bare `10` is not a typo the agent
+            // can spot: it IS a valid interval (10 SECONDS), while an operator who
+            // meant ten minutes needs the `m` suffix.
+            console.error(theme.error(t('sched.interval_typo', { v: intervalStr })));
+            return;
+        }
+        if (!ms || !taskStr) {
+            console.error(theme.error(t('sched.loop_usage')));
+            return;
+        }
+        // A very short loop (e.g. "/loop 1s ...") would keep the agent sending
+        // back-to-back and hit the rate limit. Enforce a floor; the send throttle
+        // is 15s, so anything faster is pointless anyway.
+        if (ms < MIN_LOOP_MS) {
+            console.error(theme.error(t('sched.loop_too_short', {
+                min: formatInterval(MIN_LOOP_MS),
+            })));
+            return;
+        }
+        const job = scheduler.addLoop(ms, taskStr, Date.now());
+        startScheduleTicker();
+        console.log(theme.system(t('sched.added', {
+            id: String(job.id),
+            when: formatInterval(ms),
+            task: taskStr,
+        })));
+        // Tell the operator WHEN it will actually run. A scheduled task never
+        // interrupts a running turn: it is queued and starts only when the
+        // agent is idle (or right after the current task). The bare "added"
+        // line made a first /loop look like a no-op, so the operator re-sent the
+        // task by hand (the very report this line answers).
+        console.log(theme.dim(t('sched.added_hint')));
+    };
+    /** /cron "<expr>" <task>. */
+    const cronCommand = (rest) => {
+        // A cron expression is exactly 5 whitespace-separated fields; the task
+        // is everything after them.
+        const parts = rest.split(/\s+/);
+        if (parts.length < 6) {
+            console.error(theme.error(t('sched.cron_usage')));
+            return;
+        }
+        const cronExpr = parts.slice(0, 5).join(' ');
+        const taskStr = parts.slice(5).join(' ').trim();
+        if (!parseCron(cronExpr) || !taskStr) {
+            console.error(theme.error(t('sched.cron_usage')));
+            return;
+        }
+        const job = scheduler.addCron(cronExpr, taskStr, Date.now());
+        if (!job) {
+            console.error(theme.error(t('sched.cron_usage')));
+            return;
+        }
+        startScheduleTicker();
+        const nextIn = formatInterval(Math.max(0, job.nextAt - Date.now()));
+        console.log(theme.system(t('sched.added', {
+            id: String(job.id),
+            when: cronExpr + ' (in ~' + nextIn + ')',
+            task: taskStr,
+        })));
+        console.log(theme.dim(t('sched.added_hint')));
+    };
+    /** /jobs [rm <id>|clear]. */
+    const jobsCommand = (raw) => {
+        const sub = raw.trim().toLowerCase();
+        if (sub === 'clear') {
+            const n = scheduler.clear();
+            if (scheduleTimer) {
+                clearInterval(scheduleTimer);
+                scheduleTimer = null;
+            }
+            console.log(theme.system(t('sched.cleared', { n: String(n) })));
+            return;
+        }
+        if (sub.startsWith('rm ') || sub.startsWith('remove ')) {
+            const id = Number(sub.replace(/^(rm|remove)\s+/, ''));
+            if (!Number.isInteger(id) || !scheduler.remove(id)) {
+                console.error(theme.error(t('sched.rm_usage')));
+                return;
             }
-            const sp = rest.indexOf(' ');
-            const name = sp === -1 ? rest : rest.slice(0, sp);
-            const focus = sp === -1 ? '' : rest.slice(sp + 1).trim();
-            const snapRoot = path.join(ZAMES_HOME, 'snapshots', name);
-            const stat = await fs.stat(snapRoot).catch(() => null);
-            if (!stat || !stat.isDirectory()) {
-                console.error(theme.error(t('self.snapshot_not_found', { v: snapRoot })));
-                continue;
+            if (!scheduler.count() && scheduleTimer) {
+                clearInterval(scheduleTimer);
+                scheduleTimer = null;
             }
-            const originalWorkdir = reviewMode
-                ? reviewMode.originalWorkdir
-                : currentWorkdir;
-            // Fresh chat + review prompt for this snapshot
-            try {
-                const { runAgentLoop: ral } = await import('./agent-loop.js');
-                const tools = mod.createTools(snapRoot, { undo: null });
-                await browser.newChat();
-                const sysPrompt = mod.buildSystemPrompt({
-                    workdir: snapRoot,
+            console.log(theme.system(t('sched.removed', { id: String(id) })));
+            return;
+        }
+        const jobs = scheduler.list();
+        if (!jobs.length) {
+            console.log(theme.dim(t('sched.none')));
+            return;
+        }
+        console.log(theme.system(t('sched.title')));
+        for (const j of jobs) {
+            console.log(theme.assistant(formatJobLine(j, Date.now())));
+        }
+        console.log(theme.dim(t('sched.remove_hint')));
+    };
+    /** /compact: summarize the chat and continue in a fresh one. */
+    const compactCommand = async () => {
+        // Compaction: ask DeepSeek (in the CURRENT chat) to compress the
+        // history into a handover summary, then start a NEW chat, resend the
+        // system prompt and post the summary as the carried-over context.
+        // Shared with the AUTO-compact path via performCompact() so both
+        // paths stay identical (same retries, same fallback, same resend).
+        const res = await performCompact({
+            browser,
+            providerLabel: providerLabel(config.provider),
+            currentChatId,
+            workdir: currentWorkdir,
+            locale: currentLocale,
+            task: task ?? undefined,
+            transcript,
+            ui: editor,
+            buildSystemPrompt: mod.buildSystemPrompt,
+            tools: mod.createTools(currentWorkdir, { undo, todos: todoStore }),
+            answerTimeoutMs: providerAnswerTimeoutMs(),
+            fallbackLimit: COMPACT_FALLBACK_LIMIT,
+            selfImprovement: devMode,
+        });
+        if (res.ok) {
+            currentChatId = res.chatId;
+            saveLastChat(currentChatId, currentWorkdir);
+            freshChatNext = false;
+            // The new chat already carries the system prompt and the context.
+            sendSystemPromptNext = false;
+        }
+    };
+    /** /goal: set/show/clear the condition. Returns whether it was SET. */
+    const goalCommand = async (line) => {
+        const sub = await handleGoal(line);
+        return sub === 'set' && !!sessionGoal;
+    };
+    /** Dev-only self-development commands (registry, group e). */
+    const selfReviewCommand = async (raw) => {
+        const focus = raw.trim();
+        // Remember where to return
+        const originalWorkdir = reviewMode
+            ? reviewMode.originalWorkdir
+            : currentWorkdir;
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        try {
+            const result = await mod.selfReview({
+                browser,
+                config,
+                focus: focus || undefined,
+                transcript,
+                locale: currentLocale,
+            });
+            // Switch to review mode:
+            //  - working directory = snapshot
+            //  - we do NOT reset the chat — inside selfReview a fresh chat was
+            //    already created and the review prompt sent, we return in it
+            reviewMode = {
+                snapDir: result.snapDir,
+                snapName: path.basename(result.snapDir),
+                originalWorkdir,
+            };
+            currentWorkdir = result.snapDir;
+            freshChatNext = false;
+            sendSystemPromptNext = false;
+            currentChatId = await browser.getCurrentChatId();
+            saveLastChat(currentChatId, currentWorkdir);
+            console.log(theme.user(t('self.review_hint', { name: reviewMode.snapName })));
+        }
+        catch (e) {
+            console.error(theme.error(t('self.review_failed')), e.message);
+            if (debug)
+                console.error(e.stack);
+        }
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    const selfFixCommand = async (raw) => {
+        const rest = raw.trim();
+        if (!rest) {
+            console.error(theme.error(t('self.fix_usage')));
+            return;
+        }
+        const sp = rest.indexOf(' ');
+        const name = sp === -1 ? rest : rest.slice(0, sp);
+        const focus = sp === -1 ? '' : rest.slice(sp + 1).trim();
+        const snapRoot = path.join(ZAMES_HOME, 'snapshots', name);
+        const stat = await fs.stat(snapRoot).catch(() => null);
+        if (!stat || !stat.isDirectory()) {
+            console.error(theme.error(t('self.snapshot_not_found', { v: snapRoot })));
+            return;
+        }
+        const originalWorkdir = reviewMode
+            ? reviewMode.originalWorkdir
+            : currentWorkdir;
+        // Fresh chat + review prompt for this snapshot
+        try {
+            const { runAgentLoop: ral } = await import('./agent-loop.js');
+            const tools = mod.createTools(snapRoot, { undo: null });
+            await browser.newChat();
+            const sysPrompt = mod.buildSystemPrompt({
+                workdir: snapRoot,
+                tools,
+                locale: currentLocale,
+            });
+            console.log(theme.system(t('self.init_review_chat')));
+            await browser.ask(sysPrompt, { timeout: 60_000 });
+            if (focus) {
+                const ui = mod.createSpinner(currentLocale);
+                ui.thinking();
+                await ral({
+                    browser,
                     tools,
+                    task: focus,
+                    workdir: snapRoot,
+                    maxIterations: currentMaxIter(),
+                    freshChat: false,
+                    sendSystemPrompt: false,
+                    transcript,
+                    onThinking: () => ui.thinking(),
+                    onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
+                    onToolResult: (r) => ui.toolResult(r),
+                    onAssistantMessage: (m) => {
+                        ui.assistant(m);
+                    },
+                    onWarning: (m) => ui.warning(m),
                     locale: currentLocale,
                 });
-                console.log(theme.system(t('self.init_review_chat')));
-                await browser.ask(sysPrompt, { timeout: 60_000 });
-                if (focus) {
-                    const ui = mod.createSpinner(currentLocale);
-                    ui.thinking();
-                    await ral({
-                        browser,
-                        tools,
-                        task: focus,
-                        workdir: snapRoot,
-                        maxIterations: currentMaxIter(),
-                        freshChat: false,
-                        sendSystemPrompt: false,
-                        transcript,
-                        onThinking: () => ui.thinking(),
-                        onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
-                        onToolResult: (r) => ui.toolResult(r),
-                        onAssistantMessage: (m) => {
-                            ui.assistant(m);
-                        },
-                        onWarning: (m) => ui.warning(m),
-                        locale: currentLocale,
-                    });
-                }
-                reviewMode = {
-                    snapDir: snapRoot,
-                    snapName: name,
-                    originalWorkdir,
-                };
-                currentWorkdir = snapRoot;
-                freshChatNext = false;
-                sendSystemPromptNext = false;
-                currentChatId = await browser.getCurrentChatId();
-                saveLastChat(currentChatId, currentWorkdir);
-                console.log(theme.user(t('self.fix_hint', { name })));
             }
-            catch (e) {
-                console.error(theme.error(t('self.enter_failed')), e.message);
+            reviewMode = {
+                snapDir: snapRoot,
+                snapName: name,
+                originalWorkdir,
+            };
+            currentWorkdir = snapRoot;
+            freshChatNext = false;
+            sendSystemPromptNext = false;
+            currentChatId = await browser.getCurrentChatId();
+            saveLastChat(currentChatId, currentWorkdir);
+            console.log(theme.user(t('self.fix_hint', { name })));
+        }
+        catch (e) {
+            console.error(theme.error(t('self.enter_failed')), e.message);
+        }
+    };
+    const selfDoneCommand = async (_raw) => {
+        if (!reviewMode) {
+            console.log(theme.system(t('self.not_in_review')));
+            return;
+        }
+        const back = reviewMode.originalWorkdir;
+        reviewMode = null;
+        currentWorkdir = back;
+        // Since the chat is busy with the review context, we'll create a new one for regular work
+        freshChatNext = true;
+        sendSystemPromptNext = true;
+        console.log(theme.system(t('self.done_hint', { v: back })));
+    };
+    const selfListCommand = async (_raw) => {
+        try {
+            await mod.selfList({ config, locale: currentLocale });
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.error')), e.message);
+        }
+    };
+    const selfDiffCommand = async (raw) => {
+        const name = raw.trim();
+        if (!name) {
+            console.error(theme.error(t('self.diff_usage')));
+            return;
+        }
+        try {
+            await mod.selfDiff({ config, name });
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.error')), e.message);
+        }
+    };
+    const selfApplyCommand = async (raw) => {
+        const name = raw.trim();
+        if (!name) {
+            console.error(theme.error(t('self.apply_usage')));
+            return;
+        }
+        try {
+            await mod.selfApply({ config, name });
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.error')), e.message);
+        }
+    };
+    const improveCommand = async (raw) => {
+        // Backlog-driven self-improvement: pick the next open BACKLOG item (or a
+        // specific id) and run the standard task loop on it. The agent reads
+        // BACKLOG.md itself for the details, so a FRESH agent needs no external
+        // context — this is the reproducible hand-off path.
+        const arg = raw.trim();
+        let backlogText;
+        try {
+            backlogText = await fs.readFile(path.join(currentWorkdir, 'BACKLOG.md'), 'utf-8');
+        }
+        catch {
+            console.error(theme.warn(t('improve.no_backlog')));
+            return;
+        }
+        const items = mod.commands.parseBacklogItems(backlogText);
+        const item = mod.commands.nextBacklogItem(items, arg || undefined);
+        if (!item) {
+            console.log(theme.dim(arg ? t('improve.not_found', { v: arg }) : t('improve.all_done')));
+            return;
+        }
+        console.log(theme.system(t('improve.start', { id: item.id, title: item.title })));
+        const improveBase = mod.createTools(currentWorkdir, {
+            undo,
+            todos: todoStore,
+            readOnly: planMode,
+        });
+        const improveTools = mergeTools(improveBase, mcpPool?.tools, planMode);
+        if (editor)
+            editor.busy = true;
+        try {
+            await mod.runTask(runTaskDeps(), browser, improveTools, mod.commands.buildImprovePrompt(item), currentWorkdir, {
+                transcript,
+                freshChat: false,
+                sendSystemPrompt: false,
+                queue: pendingQueue,
+                ui: editor || null,
+                onChatReady: (chatId) => {
+                    if (chatId) {
+                        currentChatId = chatId;
+                        saveLastChat(chatId, currentWorkdir);
+                    }
+                },
+                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 { }
+    };
+    const backlogCommand = async (raw) => {
+        // 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 = raw.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')));
+            return;
+        }
+        if (!note) {
+            console.log(theme.dim(t('backlog.usage')));
+            return;
+        }
+        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) })));
+            }
+            return;
+        }
+        // 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.
+        const parsed = parseBacklogNote(note);
+        const res = mod.appendBacklogItem(backlogText, parsed);
+        await fs.writeFile(backlogFile, res.text, 'utf-8');
+        console.log(theme.system(t('backlog.adding', { v: res.id })));
+    };
+    while (running) {
+        let input;
+        let inputAttachments = [];
+        // Set by `/goal <condition>` to fall through into a task turn with this
+        // text instead of returning to the prompt (Claude Code starts a turn the
+        // moment a goal is set). Reset every iteration because it is declared here.
+        let taskOverride = null;
+        // Publish the chat the next send must join (see resumeChatId above):
+        // the loop may restart the page, which loses the URL id.
+        browser.resumeChatId = resumeChatId;
+        try {
+            if (editor) {
+                editor.setPrompt(buildPrompt());
+                const msg = await takeInput();
+                input = msg ? msg.text : null;
+                inputAttachments = msg?.attachments || [];
+            }
+            else {
+                let tail;
+                // The non-TTY fallback prompt mirrors buildPrompt(): bare, no dir.
+                if (reviewMode) {
+                    // Widen: a helper function may have reset `reviewMode` to null,
+                    // which TS narrows to `never` at this point otherwise.
+                    const rm = reviewMode;
+                    tail =
+                        theme.dim('(') +
+                            theme.warn(t('prompt.review')) +
+                            theme.dim(':') +
+                            theme.dir(rm ? rm.snapName : '') +
+                            theme.dim(') ');
+                }
+                input = await promptOnce(theme.prompt('❯ ') + tail);
             }
+        }
+        catch {
+            break;
+        }
+        const trimmed = (input || '').trim();
+        if (!trimmed)
             continue;
+        const lower = trimmed.toLowerCase();
+        if (['/exit', '/quit', 'exit', 'quit'].includes(lower))
+            break;
+        // Group (a): the informational commands (/status, /chat, /pwd,
+        // /transcript, /cost, /limits, /memory, /skills). The dispatch is a DATA
+        // lookup, so the command is dispatched and advertised from the same entry.
+        {
+            const infoCommands = createInfoCommands({
+                t,
+                statusLines: () => formatStatus(statusSnapshot(), t),
+                currentChatId: () => currentChatId,
+                resolveChatId: () => browser.getCurrentChatId(),
+                chatUrl: (id) => `${browserProviderUrl()}/${id}`,
+                workdir: () => currentWorkdir,
+                transcriptFile: () => transcript.file,
+                costReport: () => {
+                    let stats = mod.commands.summarizeTranscript([]);
+                    if (transcript.file) {
+                        try {
+                            stats = mod.commands.summarizeTranscript(mod.commands.parseTranscript(readFileSync(transcript.file, 'utf-8')));
+                        }
+                        catch (e) {
+                            noteSwallowed('cost_report', e, debug);
+                        }
+                    }
+                    return [
+                        mod.commands.renderCost(stats, transcript.file, browser.getLastTokenUsage(), t),
+                    ];
+                },
+                limitsReport: async () => {
+                    const { readSendEvents, summarizeSends, sendLogPath } = await import('./send-telemetry.js');
+                    const logsDir = config.transcript.dir;
+                    const events = readSendEvents(logsDir, config.provider);
+                    if (!events.length) {
+                        return [
+                            limitsEmptyMessage(sendLogPath(logsDir, config.provider), t),
+                        ];
+                    }
+                    return formatLimits(summarizeSends(events), {
+                        providerLabel: providerLabel(config.provider),
+                        intervalMs: browser.sendIntervalMs(),
+                        adaptive: providerAdaptiveThrottle(config.provider),
+                    }, t).map((line) => line.kind === 'title' ? line.text : '  ' + line.text);
+                },
+                memoryReport: async () => {
+                    const { loadProjectContext } = await import('./context.js');
+                    const ctx = await loadProjectContext(currentWorkdir);
+                    const out = [];
+                    const show = (title, files) => {
+                        out.push(title);
+                        if (!files.length) {
+                            out.push(t('common.none'));
+                            return;
+                        }
+                        for (const f of files)
+                            out.push(f.path);
+                    };
+                    show(t('memory.agents'), ctx.agents);
+                    show(t('memory.memory'), ctx.memory);
+                    return out;
+                },
+                skillsReport: async () => {
+                    const { loadSkills } = await import('./context.js');
+                    const skills = await loadSkills(currentWorkdir);
+                    if (!skills.length)
+                        return [t('skills.none')];
+                    const out = [t('skills.title', { n: String(skills.length) })];
+                    for (const s of skills) {
+                        const src = s.path ? s.source : 'built-in';
+                        out.push('/' +
+                            s.name +
+                            ' [' +
+                            src +
+                            '] ' +
+                            (s.description || t('common.none')));
+                        if (s.path)
+                            out.push(s.path);
+                    }
+                    return out;
+                },
+            });
+            if (await dispatchCommand(infoCommands, trimmed, {
+                print: (line) => console.log(line),
+                devMode,
+            })) {
+                continue;
+            }
         }
-        if (lower === '/self-done') {
-            if (!reviewMode) {
-                console.log(theme.system(t('self.not_in_review')));
+        // Group (b): the session and chat commands (/new, /sessions, /chats,
+        // /last, /resume-id). The handlers above own the heavy logic; the registry
+        // owns the NAMES, aliases and argument forwarding.
+        {
+            const sessionCommands = createSessionCommands({
+                t,
+                newChat: () => newChatCommand(),
+                sessions: (filter) => sessionsCommand(filter),
+                chats: (filter) => chatsCommand(filter),
+                last: () => lastCommand(),
+                resumeId: (id) => resumeIdCommand(id),
+                parseResumeId: (raw) => parseResumeId(raw),
+                printResumeUsage: () => console.error(theme.error(t('sessions.resume_id_usage'))),
+            });
+            if (await dispatchCommand(sessionCommands, trimmed, {
+                print: (line) => console.log(line),
+                devMode,
+            })) {
                 continue;
             }
-            const back = reviewMode.originalWorkdir;
-            reviewMode = null;
-            currentWorkdir = back;
-            // Since the chat is busy with the review context, we'll create a new one for regular work
-            freshChatNext = true;
-            sendSystemPromptNext = true;
-            console.log(theme.system(t('self.done_hint', { v: back })));
-            continue;
         }
-        if (lower === '/self-list') {
-            try {
-                await mod.selfList({ config, locale: currentLocale });
+        // Group (c): git / undo / rewind commands (/diff, /diffstat, /undo,
+        // /undo-list, /rewind-list, /rewind).
+        {
+            const treeCommands = createTreeCommands({
+                diff: (staged) => diffCommand(staged, false),
+                diffstat: (staged) => diffCommand(staged, true),
+                undo: () => undoCommand(),
+                undoList: () => undoListCommand(),
+                rewindList: () => rewindListCommand(),
+                rewind: (selector, line) => rewindCommand(selector, line),
+            });
+            if (await dispatchCommand(treeCommands, trimmed, {
+                print: (line) => console.log(line),
+                devMode,
+            })) {
+                continue;
             }
-            catch (e) {
-                console.error(theme.error(t('msg.error')), e.message);
+        }
+        // Group (d): the scheduler and context commands (/compact, /goal, /loop,
+        // /cron, /jobs). /goal needs the result: setting a condition STARTS a
+        // turn, so the branch above (goalCommand) keeps the fall-through and this
+        // group only owns /compact, /loop, /cron and /jobs.
+        {
+            const schedulerCommands = createSchedulerCommands({
+                compact: () => compactCommand(),
+                goal: async (line) => ((await goalCommand(line)) ? 'set' : 'handled'),
+                currentGoal: () => sessionGoal,
+                loop: (rest) => loopCommand(rest),
+                cron: (rest) => cronCommand(rest),
+                jobs: (rest) => jobsCommand(rest),
+            }).filter((c) => c.name !== 'goal');
+            if (await dispatchCommand(schedulerCommands, trimmed, {
+                print: (line) => console.log(line),
+                devMode,
+            })) {
+                continue;
+            }
+        }
+        // Group (e): the dev-only self-development commands (/improve, /backlog,
+        // /self-*). Every entry carries `devOnly`, so a regular user is rejected
+        // with msg.dev_only BEFORE any handler runs (hiding them from /help is not
+        // enough — the command can be typed by hand).
+        {
+            const devCommands = createDevCommands({
+                improve: (arg) => improveCommand(arg),
+                backlog: (note) => backlogCommand(note),
+                selfReview: (focus) => selfReviewCommand(focus),
+                selfFix: (rest) => selfFixCommand(rest),
+                selfDone: () => selfDoneCommand(''),
+                selfList: () => selfListCommand(''),
+                selfDiff: (name) => selfDiffCommand(name),
+                selfApply: (name) => selfApplyCommand(name),
+            });
+            if (await dispatchCommand(devCommands, trimmed, {
+                print: (line) => console.log(line),
+                devMode,
+                onDevOnlyRejected: (name) => console.error(theme.warn(t('msg.dev_only', { v: '/' + name }))),
+            })) {
+                continue;
             }
-            continue;
         }
-        if (lower === '/self-diff' || lower.startsWith('/self-diff ')) {
-            const name = trimmed.slice('/self-diff'.length).trim();
-            if (!name) {
-                console.error(theme.error(t('self.diff_usage')));
+        // `!command` — run a shell command directly, without asking the model
+        // (like Claude Code's bash mode). The same sandbox guard as the Bash tool
+        // applies, so a direct command cannot leave the project either.
+        if (trimmed.startsWith('!')) {
+            const cmd = trimmed.slice(1).trim();
+            if (!cmd) {
+                console.error(theme.warn(t('shell.empty')));
                 continue;
             }
             try {
-                await mod.selfDiff({ config, name });
+                assertCommandInsideRoot(currentWorkdir, cmd);
             }
             catch (e) {
-                console.error(theme.error(t('msg.error')), e.message);
-            }
-            continue;
-        }
-        if (lower === '/self-apply' || lower.startsWith('/self-apply ')) {
-            const name = trimmed.slice('/self-apply'.length).trim();
-            if (!name) {
-                console.error(theme.error(t('self.apply_usage')));
+                console.error(theme.error(e.message));
                 continue;
             }
+            transcript.log('shell_command', { command: cmd });
+            if (editor)
+                editor.lock(t('shell.running'));
             try {
-                await mod.selfApply({ config, name });
+                const out = await runShell(currentWorkdir, cmd);
+                console.log(theme.system(out));
+                transcript.log('shell_result', { command: cmd, result: out });
             }
-            catch (e) {
-                console.error(theme.error(t('msg.error')), e.message);
+            finally {
+                if (editor)
+                    editor.unlock();
             }
             continue;
         }
-        if (lower === '/chats' || lower.startsWith('/chats ')) {
-            const filter = trimmed.slice('/chats'.length).trim().toLowerCase();
-            const spin = editor || mod.createSpinner(currentLocale);
-            if (editor)
-                editor.lock(t('msg.input_locked'));
-            spin.thinking();
-            try {
-                const all = await browser.listChats(30);
-                // Hide subagent chats: they are real DeepSeek chats, but they are
-                // internal context-isolation artifacts whose report already lives in
-                // the parent chat, so resuming one is never what the operator wants.
-                // The scraper runs inside the page and cannot localize: a row without
-                // text comes back with an EMPTY title, so the label is applied HERE
-                // (one place, in the operator's language) instead of a hardcoded one.
-                lastChats = all
-                    .filter((c) => !isInternalChat(c.id))
-                    .map((c) => ({
-                    ...c,
-                    title: c.title && c.title.trim() ? c.title : t('chats.untitled'),
-                }));
-                spin.stop();
-                // An optional query filters by title (substring, case-insensitive),
-                // so a long chat list does not have to be scanned by eye.
-                const shown = filter
-                    ? lastChats.filter((c) => c.title.toLowerCase().includes(filter))
-                    : lastChats;
-                if (!shown.length) {
-                    console.log(theme.system(t('chats.none_hint')));
+        if (lower === '/help' ||
+            lower === 'help' ||
+            lower.startsWith('/help ') ||
+            lower.startsWith('help ')) {
+            const topic = trimmed.replace(/^\/?help\s*/i, '').trim();
+            if (!topic) {
+                printHelp();
+            }
+            else {
+                // /help <command> — print the full description of ONE command instead
+                // of making the operator scroll the whole list.
+                const q = '/' + topic.replace(/^\//, '').toLowerCase();
+                const match = buildSlashCommands().filter((c) => c.name.toLowerCase() === q ||
+                    c.name.toLowerCase().startsWith(q + ' '));
+                if (!match.length) {
+                    console.error(theme.warn(t('help.no_topic', { v: topic })));
                 }
                 else {
-                    // In the TUI, open a real SELECT LIST (like /model) instead of
-                    // dumping text: pick a chat and it opens directly. The text path
-                    // below stays for non-TTY / the legacy editor.
-                    const canPick = editor && 'isTui' in editor && config.ui.tui && !filter;
-                    if (canPick && editor) {
-                        const openChat = await pickChatInteractively(shown);
-                        if (openChat)
-                            continue;
-                    }
-                    console.log(theme.system(t('chats.recent')));
-                    // The number is the index in the FULL list (a filter only narrows
-                    // the VIEW), and the full id in brackets is what /resume-id takes.
-                    for (const c of shown) {
-                        const idx = lastChats.indexOf(c);
-                        const n = String(idx + 1).padStart(2, ' ');
-                        console.log(`  ${theme.user(n)}. ${c.title}  ${theme.system('(' + c.id.slice(0, 8) + '…)')}`);
+                    for (const c of match) {
+                        console.log(theme.assistant(c.name) + theme.dim('  ' + c.description));
                     }
-                    console.log(theme.system(t('chats.use_resume')));
                 }
             }
-            catch (e) {
-                spin.stop();
-                console.error(theme.error(t('chats.fetch_error')), e.message);
-            }
-            finally {
-                if (editor)
-                    editor.unlock();
-            }
             continue;
         }
         if (lower === '/provider' || lower.startsWith('/provider ')) {
@@ -3054,128 +3919,14 @@ async function main() {
             }
             continue;
         }
-        if (lower === '/sessions' ||
-            lower === '/session' ||
-            lower.startsWith('/sessions ') ||
-            lower.startsWith('/session ')) {
-            const filter = trimmed
-                .replace(/^\/sessions?/i, '')
-                .trim()
-                .toLowerCase();
-            // /sessions <query> filters by title or workdir (substring). Sorted by
-            // recency already (listSessions).
-            const all = filterSessions(listSessions(), filter);
-            console.log(theme.system(t('sessions.dir', { v: sessionsDir() })));
-            if (!all.length) {
-                console.log(theme.system(t('sessions.none')));
-            }
-            else {
-                // In the TUI, open a SELECT LIST and resume the chosen session
-                // directly (same behavior as /chats), instead of only listing ids.
-                const canPick = editor && 'isTui' in editor && config.ui.tui && !filter;
-                if (canPick && editor) {
-                    const opened = await pickSessionInteractively(all);
-                    if (opened)
-                        continue;
-                }
-                all.forEach((s, i) => {
-                    const n = String(i + 1).padStart(2, ' ');
-                    const mark = s.id === currentChatId ? theme.user(' *') : '';
-                    const title = s.title ? `  ${s.title}` : '';
-                    const wd = s.workdir ? theme.dim(`  [${dirLabel(s.workdir)}]`) : '';
-                    const age = mod.commands.formatRelativeTime(s.updatedAt, t);
-                    const ageText = age ? theme.dim('  ' + age) : '';
-                    console.log(`  ${theme.user(n)}. ${s.id.slice(0, 8)}…${title}${wd}${ageText}${mark}`);
-                });
-                console.log(theme.system(t('sessions.restore_hint')));
-            }
-            continue;
-        }
-        if (lower === '/last') {
-            // Quick resume of the last chat for THIS working directory — otherwise
-            // finding it meant /chats (a network fetch) or copying the id.
-            const last = loadLastSession(currentWorkdir, config.provider);
-            if (!last || !last.id) {
-                console.error(theme.error(t('sessions.none_here')));
-                continue;
-            }
-            if (editor)
-                editor.lock(t('msg.input_locked'));
-            try {
-                if (editor)
-                    editor.clearScreen();
-                console.log(theme.system(t('msg.opening_chat', { id: last.id })));
-                await browser.openChat(last.id);
-                currentChatId = last.id;
-                freshChatNext = false;
-                sendSystemPromptNext = promptOnResume();
-                saveLastChat(last.id, currentWorkdir, last.title);
-                transcript.log('resume_chat', { id: last.id, title: last.title });
-                console.log(theme.assistant(t('msg.chat_opened')));
-                loadSessionTodos(last.id);
-                await printRestoredHistory(browser, editor, last.id);
-            }
-            catch (e) {
-                console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
-            }
-            finally {
-                if (editor)
-                    editor.unlock();
-            }
-            continue;
-        }
-        if (lower.startsWith('/resume-id ')) {
-            const id = parseResumeId(trimmed.slice('/resume-id'.length));
-            if (!id) {
-                console.error(theme.error(t('sessions.resume_id_usage')));
-                continue;
-            }
-            // A chat id only exists on the backend that created it, so opening a
-            // session saved by ANOTHER provider fails deep inside the browser with a
-            // confusing error. Refuse up front and name the right /provider command.
-            const refusal = resumeProviderRefusal(readSession(id), config.provider, t);
-            if (refusal) {
-                console.error(theme.error(refusal));
-                continue;
-            }
-            if (editor)
-                editor.lock(t('msg.input_locked'));
-            try {
-                if (editor)
-                    editor.clearScreen();
-                console.log(theme.system(t('msg.opening_chat', { id })));
-                await browser.openChat(id);
-                currentChatId = id;
-                freshChatNext = false;
-                sendSystemPromptNext = promptOnResume();
-                saveLastChat(id, currentWorkdir);
-                transcript.log('resume_chat', { id });
-                console.log(theme.assistant(t('msg.chat_opened')) +
-                    theme.system(String.fromCharCode(10)));
-                loadSessionTodos(id);
-                await printRestoredHistory(browser, editor, id);
-            }
-            catch (e) {
-                console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
-            }
-            finally {
-                if (editor)
-                    editor.unlock();
-            }
-            continue;
-        }
         if (lower === '/pwd') {
             console.log(theme.system(currentWorkdir));
             continue;
         }
         if (lower === '/goal' || lower.startsWith('/goal ')) {
-            const sub = await handleGoal(trimmed);
-            // Claude Code parity: setting a goal STARTS a turn immediately, with the
-            // condition itself as the directive (no separate prompt needed). The
-            // completion loop in runTask() then keeps working until the evaluator
-            // reports MET/IMPOSSIBLE. We fall through to the regular task path with
-            // an override task text instead of returning to the prompt.
-            if (sub === 'set' && sessionGoal) {
+            // A freshly SET goal FALLS THROUGH: the condition itself becomes the
+            // next task instead of returning to the prompt (Claude Code parity).
+            if (await goalCommand(trimmed)) {
                 taskOverride =
                     'Work toward this completion goal until it is satisfied. ' +
                         'Do not call respond with a final summary until the condition is met.';
@@ -3184,113 +3935,6 @@ async function main() {
                 continue;
             }
         }
-        if (lower === '/loop' || lower.startsWith('/loop ')) {
-            const rest = trimmed.slice('/loop'.length).trim();
-            const sp = rest.indexOf(' ');
-            const intervalStr = sp === -1 ? rest : rest.slice(0, sp);
-            const taskStr = sp === -1 ? '' : rest.slice(sp + 1).trim();
-            const ms = parseInterval(intervalStr);
-            if (!ms && intervalStr) {
-                // Say WHY the job was not added. A bare `10` is not a typo the agent
-                // can spot: it IS a valid interval (10 SECONDS), while an operator who
-                // meant ten minutes needs the `m` suffix.
-                console.error(theme.error(t('sched.interval_typo', { v: intervalStr })));
-                continue;
-            }
-            if (!ms || !taskStr) {
-                console.error(theme.error(t('sched.loop_usage')));
-                continue;
-            }
-            // A very short loop (e.g. "/loop 1s ...") would keep the agent sending
-            // back-to-back and hit the rate limit. Enforce a floor; the send throttle
-            // is 15s, so anything faster is pointless anyway.
-            if (ms < MIN_LOOP_MS) {
-                console.error(theme.error(t('sched.loop_too_short', {
-                    min: formatInterval(MIN_LOOP_MS),
-                })));
-                continue;
-            }
-            const job = scheduler.addLoop(ms, taskStr, Date.now());
-            startScheduleTicker();
-            console.log(theme.system(t('sched.added', {
-                id: String(job.id),
-                when: formatInterval(ms),
-                task: taskStr,
-            })));
-            // Tell the operator WHEN it will actually run. A scheduled task never
-            // interrupts a running turn: it is queued and starts only when the
-            // agent is idle (or right after the current task). The bare "added"
-            // line made a first /loop look like a no-op, so the operator re-sent the
-            // task by hand (the very report this line answers).
-            console.log(theme.dim(t('sched.added_hint')));
-            continue;
-        }
-        if (lower === '/cron' || lower.startsWith('/cron ')) {
-            const rest = trimmed.slice('/cron'.length).trim();
-            // A cron expression is exactly 5 whitespace-separated fields; the task
-            // is everything after them.
-            const parts = rest.split(/\s+/);
-            if (parts.length < 6) {
-                console.error(theme.error(t('sched.cron_usage')));
-                continue;
-            }
-            const cronExpr = parts.slice(0, 5).join(' ');
-            const taskStr = parts.slice(5).join(' ').trim();
-            if (!parseCron(cronExpr) || !taskStr) {
-                console.error(theme.error(t('sched.cron_usage')));
-                continue;
-            }
-            const job = scheduler.addCron(cronExpr, taskStr, Date.now());
-            if (!job) {
-                console.error(theme.error(t('sched.cron_usage')));
-                continue;
-            }
-            startScheduleTicker();
-            const nextIn = formatInterval(Math.max(0, job.nextAt - Date.now()));
-            console.log(theme.system(t('sched.added', {
-                id: String(job.id),
-                when: cronExpr + ' (in ~' + nextIn + ')',
-                task: taskStr,
-            })));
-            console.log(theme.dim(t('sched.added_hint')));
-            continue;
-        }
-        if (lower === '/jobs' || lower.startsWith('/jobs ')) {
-            const sub = trimmed.slice('/jobs'.length).trim().toLowerCase();
-            if (sub === 'clear') {
-                const n = scheduler.clear();
-                if (scheduleTimer) {
-                    clearInterval(scheduleTimer);
-                    scheduleTimer = null;
-                }
-                console.log(theme.system(t('sched.cleared', { n: String(n) })));
-                continue;
-            }
-            if (sub.startsWith('rm ') || sub.startsWith('remove ')) {
-                const id = Number(sub.replace(/^(rm|remove)\s+/, ''));
-                if (!Number.isInteger(id) || !scheduler.remove(id)) {
-                    console.error(theme.error(t('sched.rm_usage')));
-                    continue;
-                }
-                if (!scheduler.count() && scheduleTimer) {
-                    clearInterval(scheduleTimer);
-                    scheduleTimer = null;
-                }
-                console.log(theme.system(t('sched.removed', { id: String(id) })));
-                continue;
-            }
-            const jobs = scheduler.list();
-            if (!jobs.length) {
-                console.log(theme.dim(t('sched.none')));
-                continue;
-            }
-            console.log(theme.system(t('sched.title')));
-            for (const j of jobs) {
-                console.log(theme.assistant(formatJobLine(j, Date.now())));
-            }
-            console.log(theme.dim(t('sched.remove_hint')));
-            continue;
-        }
         if (lower === '/queue' || lower.startsWith('/queue ')) {
             const q = mod.commands.parseQueueCommand(trimmed);
             const view = renderQueueView(q ? q.sub : null, pendingQueue.length, pendingQueue);
@@ -3558,35 +4202,6 @@ async function main() {
                 editor.setCommands(buildSlashCommands());
             continue;
         }
-        if (lower === '/status') {
-            const statusToggles = browser.getToggleStatesSync();
-            const statusLines = formatStatus({
-                workdir: currentWorkdir,
-                reviewMode: reviewMode ? reviewMode.snapName : null,
-                origDir: reviewMode ? reviewMode.originalWorkdir : null,
-                chatId: currentChatId,
-                freshNext: freshChatNext,
-                promptNext: sendSystemPromptNext,
-                lastChat: loadLastChat(currentWorkdir),
-                sessionsDir: sessionsDir(),
-                devMode,
-                maxIterations: currentMaxIter(),
-                headless,
-                debug,
-                deepThinking: statusToggles.deepThinking,
-                webSearch: statusToggles.webSearch,
-                undo: config.undo.enabled,
-                checkpoint: config.checkpoint.enabled,
-                transcriptFile: transcript.file,
-                goal: sessionGoal,
-                localeName: localeDisplayName(currentLocale),
-                mcpToolCount: mcpPool ? mcpPool.status().toolCount : null,
-                tokenUsage: browser.getLastTokenUsage(),
-            }, t);
-            for (const line of statusLines)
-                console.log(theme.system(line));
-            continue;
-        }
         if (lower === '/config' || lower.startsWith('/config ')) {
             await handleConfigCommand(trimmed);
             continue;
@@ -3695,30 +4310,6 @@ async function main() {
             }
             continue;
         }
-        if (lower === '/diff' || lower.startsWith('/diff ')) {
-            const staged = lower.indexOf('--staged') !== -1;
-            const { runGitArgs } = await import('./gitTools.js');
-            const probe = await runGitArgs(['rev-parse', '--is-inside-work-tree'], currentWorkdir, 5000);
-            if (probe.trim() !== 'true') {
-                console.error(theme.error(t('diff.not_repo')));
-                continue;
-            }
-            const out = await runGitArgs(mod.commands.diffGitArgs(staged), currentWorkdir, 20_000);
-            console.log(theme.system(mod.commands.formatDiff(out, { maxLines: 400 }, t)));
-            continue;
-        }
-        if (lower === '/diffstat' || lower.startsWith('/diffstat ')) {
-            const staged = lower.indexOf('--staged') !== -1;
-            const { runGitArgs } = await import('./gitTools.js');
-            const probe = await runGitArgs(['rev-parse', '--is-inside-work-tree'], currentWorkdir, 5000);
-            if (probe.trim() !== 'true') {
-                console.error(theme.error(t('diff.not_repo')));
-                continue;
-            }
-            const out = await runGitArgs(mod.commands.diffStatGitArgs(staged), currentWorkdir, 20_000);
-            console.log(theme.system(mod.commands.formatDiffStat(out, { maxLines: 60 }, t)));
-            continue;
-        }
         if (lower === '/limits') {
             const { readSendEvents, summarizeSends, sendLogPath } = await import('./send-telemetry.js');
             const logsDir = config.transcript.dir;
@@ -3821,6 +4412,35 @@ async function main() {
                 transcriptOk: !!transcript.file,
                 authSaved: authMarkerExists(),
                 contextLimit: effectiveContextLimit(),
+                // N12: the system-prompt size against the N6 budget. The prompt
+                // is rebuilt here because /doctor is a READ-ONLY view: nothing
+                // else in the process holds the string.
+                systemPromptBytes: Buffer.byteLength(mod.buildSystemPrompt({
+                    workdir: currentWorkdir,
+                    tools: mod.createTools(currentWorkdir, {
+                        undo,
+                        todos: todoStore,
+                    }),
+                    locale: currentLocale,
+                    selfImprovement: devMode,
+                    provider: config.provider,
+                })),
+                systemPromptBudget: SYSTEM_PROMPT_BUDGET_BYTES,
+                // N21: WHERE the password lives, and whether that store is real
+                // on this machine (a degraded keychain shows as a WARN).
+                passwordStore: resolvePasswordStore(config.browser.passwordStore, {
+                    secretTool: false,
+                    security: false,
+                    powershell: false,
+                    platform: process.platform === 'darwin'
+                        ? 'darwin'
+                        : process.platform === 'win32'
+                            ? 'win32'
+                            : 'linux',
+                }),
+                // N7: the top swallowed-failure tags — a broken selector stops
+                // being invisible.
+                swallowedTop: swallowedReport(5),
                 hasOrigin: gitOk
                     ? (await runGitArgs(['remote'], currentWorkdir, 5000)).includes('origin')
                     : undefined,
@@ -3857,139 +4477,6 @@ async function main() {
             console.log(theme.system(t('adddir.note', { v: res.path })));
             continue;
         }
-        if (lower === '/compact') {
-            // Compaction: ask DeepSeek (in the CURRENT chat) to compress the
-            // history into a handover summary, then start a NEW chat, resend the
-            // system prompt and post the summary as the carried-over context.
-            // Shared with the AUTO-compact path via performCompact() so both
-            // paths stay identical (same retries, same fallback, same resend).
-            const res = await performCompact({
-                browser,
-                providerLabel: providerLabel(config.provider),
-                currentChatId,
-                workdir: currentWorkdir,
-                locale: currentLocale,
-                task: task ?? undefined,
-                transcript,
-                ui: editor,
-                buildSystemPrompt: mod.buildSystemPrompt,
-                tools: mod.createTools(currentWorkdir, { undo, todos: todoStore }),
-                answerTimeoutMs: providerAnswerTimeoutMs(),
-                fallbackLimit: COMPACT_FALLBACK_LIMIT,
-                selfImprovement: devMode,
-            });
-            if (res.ok) {
-                currentChatId = res.chatId;
-                saveLastChat(currentChatId, currentWorkdir);
-                freshChatNext = false;
-                // The new chat already carries the system prompt and the context.
-                sendSystemPromptNext = false;
-            }
-            continue;
-        }
-        if (lower === '/improve' || lower.startsWith('/improve ')) {
-            // Backlog-driven self-improvement: pick the next open BACKLOG item (or a
-            // specific id) and run the standard task loop on it. The agent reads
-            // BACKLOG.md itself for the details, so a FRESH agent needs no external
-            // context — this is the reproducible hand-off path.
-            const arg = trimmed.slice('/improve'.length).trim();
-            let backlogText;
-            try {
-                backlogText = await fs.readFile(path.join(currentWorkdir, 'BACKLOG.md'), 'utf-8');
-            }
-            catch {
-                console.error(theme.warn(t('improve.no_backlog')));
-                continue;
-            }
-            const items = mod.commands.parseBacklogItems(backlogText);
-            const item = mod.commands.nextBacklogItem(items, arg || undefined);
-            if (!item) {
-                console.log(theme.dim(arg ? t('improve.not_found', { v: arg }) : t('improve.all_done')));
-                continue;
-            }
-            console.log(theme.system(t('improve.start', { id: item.id, title: item.title })));
-            const improveBase = mod.createTools(currentWorkdir, {
-                undo,
-                todos: todoStore,
-                readOnly: planMode,
-            });
-            const improveTools = mergeTools(improveBase, mcpPool?.tools, planMode);
-            if (editor)
-                editor.busy = true;
-            try {
-                await mod.runTask(runTaskDeps(), browser, improveTools, mod.commands.buildImprovePrompt(item), currentWorkdir, {
-                    transcript,
-                    freshChat: false,
-                    sendSystemPrompt: false,
-                    queue: pendingQueue,
-                    ui: editor || null,
-                    onChatReady: (chatId) => {
-                        if (chatId) {
-                            currentChatId = chatId;
-                            saveLastChat(chatId, currentWorkdir);
-                        }
-                    },
-                    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.
-            const parsed = parseBacklogNote(note);
-            const res = mod.appendBacklogItem(backlogText, parsed);
-            await fs.writeFile(backlogFile, res.text, 'utf-8');
-            console.log(theme.system(t('backlog.adding', { v: res.id })));
-            continue;
-        }
         if (lower === '/review' || lower.startsWith('/review ')) {
             const rest = trimmed.slice('/review'.length).trim();
             const staged = rest.indexOf('--staged') !== -1;
@@ -4021,128 +4508,6 @@ async function main() {
             }
             continue;
         }
-        if (lower === '/undo') {
-            const result = await undo.undoLast();
-            if (result.ok && result.record) {
-                console.log(theme.assistant(t('undo.reverted', { v: result.record.originalPath })) +
-                    theme.system(result.record.existed ? t('undo.restored') : t('undo.deleted')));
-                transcript.log('undo', { path: result.record.originalPath });
-            }
-            else {
-                // undo.ts returns machine codes ('empty'/'disabled') — localize here so
-                // an English UI never shows a Russian reason.
-                const reasonKey = result.reason === 'empty'
-                    ? 'undo.reason_empty'
-                    : result.reason === 'disabled'
-                        ? 'undo.reason_disabled'
-                        : null;
-                const reason = reasonKey ? t(reasonKey) : String(result.reason ?? '');
-                console.error(theme.error(t('undo.failed', { v: reason })));
-            }
-            continue;
-        }
-        if (lower === '/undo-list' || lower === '/history') {
-            const list = await undo.list(10);
-            if (!list.length) {
-                console.log(theme.system(t('undo.empty')));
-            }
-            else {
-                for (const r of list) {
-                    const stamp = undoDateLabel(r.stamp);
-                    const flag = r.existed ? t('undo.changed') : t('undo.created');
-                    console.log(theme.system(`${stamp}  [${flag}]  ${r.originalPath}`));
-                }
-            }
-            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 = undoDateLabel(r.stamp);
-                    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 {
-                // The DISPLAY window is the newest 10, but a FULL stamp must resolve
-                // against the whole index (restore() searches all of it): an older
-                // checkpoint picked by its stamp used to report "/rewind failed", and a
-                // stamp sharing its first digits with a newer one could resolve to
-                // THAT wrong record.
-                const list = await checkpoints.list(10);
-                const all = isFullStampSelector(selector)
-                    ? await checkpoints.list(Number.MAX_SAFE_INTEGER)
-                    : list;
-                const target = pickCheckpoint(list, selector, all);
-                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`);
@@ -4354,6 +4719,11 @@ async function main() {
                     }
                     : null,
                 onContextLimit: recoverFromContextLimit,
+                // N8: when the active provider exhausted its retries, continue on an
+                // AUTHORIZED fallback (auth marker + a confirmed login, never a
+                // guest) when the operator configured one. The switch reuses the
+                // existing provider handoff; the SAME task is then retried.
+                onProviderExhausted: async (err) => await fallbackToAuthorizedProvider(err),
                 autoCompactPct: config.browser.autoCompactPct,
                 contextLimit: effectiveContextLimit(),
                 getTokenUsage: () => browser.getLastTokenUsage(),