zames_pro 2.73.11 → 2.75.0

package/dist/index.js

@@ -14,10 +14,12 @@ import { runAgentLoop } from './agent-loop.js';
 import { createSubagentRunner } from './subagent.js';
 import { createSpinner } from './spinner.js';
 import { LineEditor } from './input.js';
+import { TuiEditor } from './tui/TuiEditor.js';
 import { promptOnce } from './prompt.js';
 import { parseImagePaste, extForMime, saveToTemp, guessMime, formatSize, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, writeClipboardText, contentHash, } from './attachments.js';
 import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, providerAskDeadlineMs, } from './config.js';
 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';
@@ -26,10 +28,15 @@ import { UndoStore } from './undo.js';
 import { CheckpointStore, pickRecord as pickCheckpoint } from './checkpoint.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
 import { performCompact } from './compact.js';
+import { clampGoalCondition } from './goal.js';
+import { applyBrowserLiveConfig, applyStoreLiveConfig } from './config-live.js';
 import { buildHandoffText, saveProviderHandoff, readProviderHandoff, clearProviderHandoff, } from './provider-handoff.js';
 import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } from './scheduler.js';
 import { createCliArgs } from './cli-args.js';
 import { renderMarkdown, setAnswerWidth } from './markdown.js';
+import { extractCodeBlocks } from './code-blocks.js';
+import { contentWidth } from './width.js';
+import { renderStartupBanner } from './banner.js';
 import { runStatusLineCommand } from './statusline.js';
 import { parseBacklogNote } from './backlog.js';
 import { askOperatorConfirm, } from './run-task.js';
@@ -108,10 +115,14 @@ const maxIterArg = getArg('--max-iter', null);
 // A non-numeric `--max-iter abc` yields NaN, which the loop treats as
 // "unlimited" (NaN > 0 is false). Fall back to the configured value instead
 // of silently disabling the cap.
+// The CLI value OVERRIDES the config for the whole run; when no flag is
+// given, the value is read from config LIVE so `/config set maxIterations`
+// takes effect on the next task.
 const maxIterParsed = maxIterArg !== null ? Number(maxIterArg) : NaN;
-const maxIter = Number.isFinite(maxIterParsed)
-    ? maxIterParsed
-    : config.maxIterations;
+const maxIterOverride = Number.isFinite(maxIterParsed) ? maxIterParsed : null;
+function currentMaxIter() {
+    return maxIterOverride !== null ? maxIterOverride : config.maxIterations;
+}
 const positional = getPositional();
 const task = getArg('--task', positional.join(' ').trim() || null);
 const chatIdArg = getArg('--chat', null);
@@ -426,6 +437,8 @@ ${theme.bold(t('help.while_working'))}
   ${t('help.key.attach')}
   ${t('help.key.esc')}
   ${t('help.key.bang')}
+  ${t('help.key.scroll')}
+  ${t('help.key.wheel')}
 
 ${theme.bold(t('help.commands'))}
 
@@ -780,7 +793,7 @@ function runTaskDeps() {
         t,
         locale: currentLocale,
         debug,
-        maxIter,
+        maxIter: currentMaxIter(),
         config,
         runAgentLoop: mod.runAgentLoop,
         createSpinner: mod.createSpinner,
@@ -817,8 +830,21 @@ async function main() {
         console.error(theme.error(t('msg.workdir_error')), e.message);
         process.exit(1);
     }
-    console.log(theme.system(t('msg.working_dir', { v: currentWorkdir })));
-    console.log(theme.system(t('msg.version', { v: pkgVersion || '?' })));
+    // A styled startup banner in an interactive terminal; a plain two-line
+    // header when the output is piped (scripts/CI parse it).
+    if (process.stdout.isTTY && !jsonMode && config.ui.tui) {
+        console.log(renderStartupBanner({
+            title: 'zames',
+            version: pkgVersion || '?',
+            workdir: currentWorkdir,
+            provider: providerLabel(config.provider),
+            hint: t('msg.banner_hint'),
+        }, contentWidth()));
+    }
+    else {
+        console.log(theme.system(t('msg.working_dir', { v: currentWorkdir })));
+        console.log(theme.system(t('msg.version', { v: pkgVersion || '?' })));
+    }
     const transcript = new Transcript({
         dir: config.transcript.dir,
         enabled: config.transcript.enabled,
@@ -1193,6 +1219,10 @@ async function main() {
     // the typed text is never overwritten by output. In non-TTY (pipe) —
     // the old promptOnce.
     let editor = null;
+    // Re-wire the browser login callbacks after the editor exists / a provider
+    // swap. Assigned where the editor is built (see the login wiring below);
+    // a no-op until then so /provider before setup is harmless.
+    let wireLoginCallbacks = () => { };
     // N37 statusLine hook timer (cleared on exit).
     let statusLineTimer = null;
     let waiter = null;
@@ -1218,19 +1248,36 @@ async function main() {
     };
     await refreshDynamicCommands(currentWorkdir);
     if (process.stdin.isTTY && process.stdout.isTTY) {
-        const ed = new LineEditor({
-            prompt: buildPrompt(),
-            commands: buildSlashCommands(),
-            locale: currentLocale,
-        });
+        const ed = config.ui.tui
+            ? new TuiEditor({
+                prompt: buildPrompt(),
+                commands: buildSlashCommands(),
+                locale: currentLocale,
+                alternateScreen: config.ui.alternateScreen,
+            })
+            : new LineEditor({
+                prompt: buildPrompt(),
+                commands: buildSlashCommands(),
+                locale: currentLocale,
+            });
         editor = ed;
         ed.setTmpDir(TMP_DIR);
         // Provider badge: show which backend is answering ([Qwen]/[DeepSeek]).
         ed.setProvider(providerLabel(config.provider));
+        // Header for full-screen mode (title / version / working directory).
+        ed.setHeader?.({
+            title: 'zames',
+            version: pkgVersion || '',
+            workdir: currentWorkdir,
+            mouseScroll: config.ui.mouseScroll,
+        });
         // Restore the input history from the previous runs and persist every new
         // entry, so Ctrl+R / arrows can recall older messages after a restart.
         ed.history = loadHistory();
-        ed._histIndex = ed.history.length;
+        // The legacy LineEditor keeps its own browse index; the TUI seeds it from
+        // the history itself.
+        if (ed instanceof LineEditor)
+            ed._histIndex = ed.history.length;
         ed.onHistoryChange = (h) => saveHistory(h);
         // The token context right-aligned on the status line (above the input).
         // The editor pulls the number on every render, so it follows the live
@@ -1247,6 +1294,81 @@ async function main() {
         // Toggle icons (🧠 deep thinking, 🌐 web search) before the context
         // counter. The editor pulls the live state on every render.
         ed.onToggleQuery = () => browser.getToggleStatesSync();
+        // Interactive login goes through the Ink form when the TUI owns the
+        // terminal: the browser's readline/askPassword would PAUSE the whole TUI
+        // and fight Ink for stdin. A NAMED function so /provider can re-wire the
+        // freshly created browser (the factory runs before `editor` exists, so the
+        // callbacks cannot be passed there without a forward reference).
+        wireLoginCallbacks = (b) => {
+            // The DeepSeek and Qwen browsers expose DIFFERENT login callback shapes
+            // (DeepSeek: login+password / MFA; Qwen: email -> one-time code), so the
+            // wiring is branched on the provider rather than forced through one
+            // shape.
+            const bb = b;
+            if (config.provider === 'qwen') {
+                bb.onLoginPrompt = async (info) => {
+                    if (!config.ui.tui || !(ed instanceof TuiEditor))
+                        return null;
+                    ed.pause();
+                    try {
+                        const { runTextPrompt } = await import('./tui/run-login.js');
+                        const isCode = info.step === 'code';
+                        return await runTextPrompt({
+                            t,
+                            label: isCode
+                                ? t('qwen.login_code_prompt')
+                                : t('qwen.login_email_prompt', {
+                                    def: info.savedUsername
+                                        ? ' [' + info.savedUsername + ']'
+                                        : '',
+                                }),
+                            secret: isCode,
+                        });
+                    }
+                    finally {
+                        ed.resume();
+                    }
+                };
+            }
+            else {
+                bb.onLoginPrompt = async (info) => {
+                    if (!config.ui.tui || !(ed instanceof TuiEditor))
+                        return null;
+                    ed.pause();
+                    try {
+                        const { runLoginForm } = await import('./tui/run-login.js');
+                        return await runLoginForm({
+                            t,
+                            initialUsername: config.browser.auth.username,
+                            initialPassword: config.browser.auth.password,
+                            note: info.hasSavedPassword || info.savedUsername
+                                ? t('auth.form.note_saved')
+                                : undefined,
+                        });
+                    }
+                    finally {
+                        ed.resume();
+                    }
+                };
+            }
+            bb.onMfaPrompt = async () => {
+                if (!config.ui.tui || !(ed instanceof TuiEditor))
+                    return null;
+                ed.pause();
+                try {
+                    const { runTextPrompt } = await import('./tui/run-login.js');
+                    return await runTextPrompt({
+                        t,
+                        label: t('auth.mfa_prompt'),
+                        secret: true,
+                    });
+                }
+                finally {
+                    ed.resume();
+                }
+            };
+        };
+        wireLoginCallbacks(browser);
         // N37 statusLine hook: run the configured command on its own timer (never
         // per-render — a spawn would block typing) and show its first stdout line
         // in the status line. Off when ui.statusLineCommand is empty.
@@ -1363,6 +1485,7 @@ async function main() {
             }) + theme.dim('  (' + res.via + ')')));
             return att;
         };
+        ed.onCopyText = (text) => writeClipboardText(text);
         ed.onSubmit = (text, items) => {
             // While the agent is busy the main command loop is blocked on
             // `await runTask()`, so ONLY commands that make sense without the main
@@ -1473,7 +1596,23 @@ async function main() {
                 }
             }
         };
-        ed.start();
+        try {
+            ed.start();
+            // One-time hint so the operator knows how selection works: with wheel
+            // scrolling on (the default) the terminal no longer selects natively, so
+            // a drag needs Shift. Printed ONCE, above the input, in full-screen TUI
+            // only (the legacy editor keeps native selection).
+            if (config.ui.tui && config.ui.alternateScreen) {
+                ed.printAbove(theme.dim(t('msg.mouse_hint')));
+            }
+        }
+        catch (e) {
+            // A TUI mount failure must not kill the agent. We surface it and let the
+            // operator retry with `ui.tui: false` if it persists; the imperative
+            // callbacks stay bound to the same editor object, so no state is lost.
+            console.error(theme.warn('UI start failed (set ui.tui=false to use the legacy editor): ' +
+                String(e)));
+        }
         // All command output (console.log/error) must go ABOVE the input line,
         // otherwise it overwrites the text being typed. While the editor is
         // active, we wrap both streams in ed.printAbove.
@@ -1560,6 +1699,63 @@ async function main() {
                 editor.refreshStatus();
             }
         }
+        // Browser TIMING knobs (timeouts, retries, the send throttle) are COPIED
+        // by the browser at construction, so push them onto the live instance.
+        // (deepThinking/webSearch are handled above because they also repaint the
+        // status icons.)
+        if (path.startsWith('browser.')) {
+            const b = browser;
+            if (applyBrowserLiveConfig(path, value, b)) {
+                // minSendIntervalMs feeds the send countdown the UI renders.
+                if (editor)
+                    editor.refreshStatus();
+            }
+        }
+        // The undo/checkpoint stores also copy their config at construction.
+        applyStoreLiveConfig(path, value, {
+            undo: undo,
+            checkpoints: checkpoints,
+        });
+        // Qwen timing knobs feed the QwenBrowser constructor. Its LIVE fields use
+        // the SAME names, so push them there when the active backend is Qwen (a
+        // no-op on DeepSeek, which has no qwen-only knobs).
+        if (path === 'qwen.minSendIntervalMs' || path === 'qwen.answerTimeoutMs') {
+            const b = browser;
+            if (config.provider === 'qwen') {
+                const field = path === 'qwen.minSendIntervalMs'
+                    ? 'minSendIntervalMs'
+                    : 'answerTimeoutMs';
+                if (field in b) {
+                    b[field] = value;
+                    if (editor)
+                        editor.refreshStatus();
+                }
+            }
+        }
+        // Switching the provider from /config cannot be applied live (it needs a
+        // new browser); tell the operator instead of silently doing nothing.
+        if (path === 'provider') {
+            const line = t('cfg.provider_restart');
+            if (editor)
+                editor.printAbove(theme.warn(line));
+            else
+                console.log(theme.warn(line));
+        }
+        // headless is fixed at launch (the browser is already open); a /config set
+        // only takes effect on the next run.
+        if (path === 'headless') {
+            const line = t('cfg.restart_required');
+            if (editor)
+                editor.printAbove(theme.dim(line));
+            else
+                console.log(theme.dim(line));
+        }
+        // transcript.enabled: the Transcript copies the flag at construction. A
+        // false -> true flip cannot open a NEW stream mid-run, but true -> false
+        // can (and should) stop writing immediately.
+        if (path === 'transcript.enabled' && value === false) {
+            transcript.enabled = false;
+        }
     }
     // Apply `/thinking` / `/web` immediately: flip the browser's DESIRED state
     // and the status icons, and persist to config (so it survives a restart).
@@ -1598,11 +1794,13 @@ async function main() {
     // Handle a `/goal` command shared by the main loop and the live interception
     // (so a goal can be set even while the agent is busy — it only touches a
     // variable and a file, never the chat). Output goes above the input line
-    // when the editor is active, otherwise to stdout.
+    // when the editor is active, otherwise to stdout. Returns which subcommand
+    // ran so the main loop can START A TURN when a goal is freshly set (Claude
+    // Code parity: setting a goal begins working toward it immediately).
     async function handleGoal(input) {
         const g = mod.commands.parseGoalCommand(input);
         if (!g)
-            return;
+            return null;
         const emit = (line) => {
             if (editor)
                 editor.printAbove(line);
@@ -1613,16 +1811,19 @@ async function main() {
             sessionGoal = null;
             await saveGoal(currentWorkdir, null);
             emit(theme.system(t('goal.cleared')));
+            return 'cleared';
         }
         else if (g.sub === 'show') {
             emit(sessionGoal
                 ? theme.system(t('goal.current', { goal: sessionGoal }))
                 : theme.dim(t('goal.none')));
+            return 'shown';
         }
         else {
-            sessionGoal = g.goal;
-            await saveGoal(currentWorkdir, g.goal);
-            emit(theme.system(t('goal.set', { goal: g.goal })));
+            sessionGoal = clampGoalCondition(g.goal);
+            await saveGoal(currentWorkdir, sessionGoal);
+            emit(theme.system(t('goal.set', { goal: sessionGoal })));
+            return 'set';
         }
     }
     function configSetRaw(field, raw) {
@@ -1650,19 +1851,27 @@ async function main() {
             return;
         }
         // The menu draws directly to stdout and reads keys itself. So that its
-        // output doesn't overlap the LineEditor's permanent input line, we "pause"
+        // output doesn't overlap the editor's permanent input line, we "pause"
         // the editor for the duration of the menu and restore it afterwards.
         if (editor)
             editor.pause();
+        const menuOpts = {
+            fields: CONFIG_SCHEMA,
+            t,
+            get: (path) => getByPath(config, path),
+            getDefault: (path) => getByPath(DEFAULTS, path),
+            set: (field, raw) => configSetRaw(field, raw),
+            reset: (field) => configResetField(field),
+        };
         try {
-            await runConfigMenu({
-                fields: CONFIG_SCHEMA,
-                t,
-                get: (path) => getByPath(config, path),
-                getDefault: (path) => getByPath(DEFAULTS, path),
-                set: (field, raw) => configSetRaw(field, raw),
-                reset: (field) => configResetField(field),
-            });
+            // Prefer the Ink menu (nicer, resize-aware) when the TUI is enabled;
+            // fall back to the legacy hand-rolled menu otherwise.
+            if (config.ui.tui) {
+                await runConfigMenuInk(menuOpts);
+            }
+            else {
+                await runConfigMenu(menuOpts);
+            }
         }
         catch (e) {
             console.error(theme.error(String(e.message || e)));
@@ -1690,9 +1899,114 @@ async function main() {
             projectConfigPath: CONFIG_PATHS.PROJECT_CONFIG,
         });
     }
+    // Open a chat by its ChatInfo and print the restored dialogue. Shared by
+    // /resume and the interactive /chats list, so both paths behave identically
+    // (todos reloaded, prompt-resend decision, transcript event).
+    const openResumedChat = async (pick) => {
+        if (editor)
+            editor.lock(t('msg.input_locked'));
+        try {
+            await browser.openChat(pick.id);
+            currentChatId = pick.id;
+            freshChatNext = false;
+            sendSystemPromptNext = promptOnResume();
+            saveLastChat(pick.id, currentWorkdir, pick.title);
+            transcript.log('resume_chat', { id: pick.id, title: pick.title });
+            if (editor)
+                editor.clearScreen();
+            console.log(theme.system(t('chats.opening', { v: pick.title })));
+            console.log(theme.assistant(t('msg.chat_opened')) +
+                theme.system(sendSystemPromptNext
+                    ? String.fromCharCode(10) + t('chats.prompt_will_resend')
+                    : String.fromCharCode(10) + t('chats.prompt_no_resend')));
+            loadSessionTodos(pick.id);
+            await printRestoredHistory(browser, editor, pick.id);
+        }
+        catch (e) {
+            console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
+        }
+        finally {
+            if (editor)
+                editor.unlock();
+        }
+    };
+    // Show the recent chats in an Ink SelectList and open the chosen one.
+    // Returns true when the operator picked a chat (the caller then skips the
+    // text listing). Only called when the TUI owns the terminal.
+    const pickChatInteractively = async (chats) => {
+        if (!editor)
+            return false;
+        editor.pause();
+        let picked = null;
+        try {
+            const { selectListInk } = await import('./tui/run-select.js');
+            picked = await selectListInk({
+                title: t('chats.pick_title'),
+                items: chats.map((c, i) => ({
+                    value: c.id,
+                    label: String(i + 1).padStart(2, ' ') + '. ' + c.title,
+                    detail: c.id.slice(0, 8) + '…',
+                })),
+            });
+        }
+        catch {
+            picked = null;
+        }
+        finally {
+            editor.resume();
+        }
+        if (!picked)
+            return false;
+        const pick = chats.find((c) => c.id === picked);
+        if (!pick)
+            return false;
+        await openResumedChat(pick);
+        return true;
+    };
+    // Show the saved SESSIONS in an Ink SelectList and resume the chosen one.
+    // Sessions carry the full chat id (unlike the /chats sidebar), so this is
+    // the safe resume path; it reuses openResumedChat for identical behavior.
+    const pickSessionInteractively = async (sessions) => {
+        if (!editor)
+            return false;
+        editor.pause();
+        let picked = null;
+        try {
+            const { selectListInk } = await import('./tui/run-select.js');
+            picked = await selectListInk({
+                title: t('sessions.pick_title'),
+                items: sessions.map((s, i) => ({
+                    value: s.id,
+                    label: String(i + 1).padStart(2, ' ') +
+                        '. ' +
+                        (s.title || s.id.slice(0, 8)),
+                    detail: s.id.slice(0, 8) +
+                        '…' +
+                        (s.workdir ? ' [' + dirLabel(s.workdir) + ']' : ''),
+                })),
+            });
+        }
+        catch {
+            picked = null;
+        }
+        finally {
+            editor.resume();
+        }
+        if (!picked)
+            return false;
+        const pick = sessions.find((s) => s.id === picked);
+        if (!pick)
+            return false;
+        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;
         try {
             if (editor) {
                 editor.setPrompt(buildPrompt());
@@ -1898,7 +2212,7 @@ async function main() {
                         tools,
                         task: focus,
                         workdir: snapRoot,
-                        maxIterations: maxIter,
+                        maxIterations: currentMaxIter(),
                         freshChat: false,
                         sendSystemPrompt: false,
                         transcript,
@@ -2003,6 +2317,15 @@ async function main() {
                     console.log(theme.system(t('chats.none_hint')));
                 }
                 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, so `/resume <n>` keeps
                     // pointing at the same chat even when a filter narrows the view.
@@ -2044,33 +2367,7 @@ async function main() {
                 console.error(theme.error(t('chats.no_n', { n, total: lastChats.length })));
                 continue;
             }
-            if (editor)
-                editor.lock(t('msg.input_locked'));
-            try {
-                await browser.openChat(pick.id);
-                currentChatId = pick.id;
-                freshChatNext = false;
-                sendSystemPromptNext = promptOnResume();
-                saveLastChat(pick.id, currentWorkdir, pick.title);
-                transcript.log('resume_chat', { id: pick.id, title: pick.title });
-                // Resume on a clean screen so the restored dialogue is readable.
-                if (editor)
-                    editor.clearScreen();
-                console.log(theme.system(t('chats.opening', { v: pick.title })));
-                console.log(theme.assistant(t('msg.chat_opened')) +
-                    theme.system(sendSystemPromptNext
-                        ? String.fromCharCode(10) + t('chats.prompt_will_resend')
-                        : String.fromCharCode(10) + t('chats.prompt_no_resend')));
-                loadSessionTodos(pick.id);
-                await printRestoredHistory(browser, editor, pick.id);
-            }
-            catch (e) {
-                console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
-            }
-            finally {
-                if (editor)
-                    editor.unlock();
-            }
+            await openResumedChat(pick);
             continue;
         }
         if (lower === '/provider' || lower.startsWith('/provider ')) {
@@ -2195,6 +2492,9 @@ async function main() {
                     // launch failed, `browser` would point at a dead instance and every
                     // later command would break.
                     const nextBrowser = createProviderBrowser(arg);
+                    // Wire the Ink login BEFORE waitForLogin(), or the new backend would
+                    // fall back to readline and pause the TUI for its sign-in.
+                    wireLoginCallbacks(nextBrowser);
                     await nextBrowser.launch();
                     await nextBrowser.waitForLogin();
                     const oldBrowser = browser;
@@ -2248,11 +2548,46 @@ async function main() {
                 const models = qb.listModels ? await qb.listModels() : [];
                 if (!models.length) {
                     console.log(theme.system(t('qwen.model_list', { v: '(none)' })));
+                    continue;
                 }
-                else {
-                    const lines = models.map((m) => `  ${m.id}  —  ${m.name}`).join(NL);
-                    console.log(theme.system(t('qwen.model_list', { v: lines })));
+                // In the TUI, open a proper SELECT LIST instead of dumping text.
+                if (editor && 'isTui' in editor && config.ui.tui) {
+                    if (editor.pause)
+                        editor.pause();
+                    let picked;
+                    try {
+                        const { selectListInk } = await import('./tui/run-select.js');
+                        picked = await selectListInk({
+                            title: t('qwen.model_pick_title'),
+                            initial: config.qwen.model || models[0].id,
+                            items: models.map((m) => ({
+                                value: m.id,
+                                label: m.name || m.id,
+                                detail: m.id === config.qwen.model ? '← текущая' : m.id,
+                            })),
+                        });
+                    }
+                    catch {
+                        picked = null;
+                    }
+                    finally {
+                        if (editor.resume)
+                            editor.resume();
+                    }
+                    if (picked) {
+                        config.qwen.model = picked;
+                        if (typeof qb.model === 'string')
+                            qb.model = picked;
+                        try {
+                            writeConfigValue('home', 'qwen.model', picked);
+                        }
+                        catch { }
+                        console.log(theme.system(t('qwen.model_set', { v: picked })));
+                    }
+                    continue;
                 }
+                const lines = models.map((m) => `  ${m.id}  —  ${m.name}`).join(NL);
+                console.log(theme.system(t('qwen.model_list', { v: lines })));
                 continue;
             }
             config.qwen.model = arg;
@@ -2294,6 +2629,14 @@ async function main() {
                 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(' *') : '';
@@ -2377,8 +2720,20 @@ async function main() {
             continue;
         }
         if (lower === '/goal' || lower.startsWith('/goal ')) {
-            await handleGoal(trimmed);
-            continue;
+            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) {
+                taskOverride =
+                    'Work toward this completion goal until it is satisfied. ' +
+                        'Do not call respond with a final summary until the condition is met.';
+            }
+            else {
+                continue;
+            }
         }
         if (lower === '/loop' || lower.startsWith('/loop ')) {
             const rest = trimmed.slice('/loop'.length).trim();
@@ -2662,7 +3017,7 @@ async function main() {
                     tools: initTools,
                     task: initTask,
                     workdir: currentWorkdir,
-                    maxIterations: maxIter,
+                    maxIterations: currentMaxIter(),
                     freshChat: freshChatNext,
                     sendSystemPrompt: sendSystemPromptNext,
                     transcript,
@@ -2761,7 +3116,7 @@ async function main() {
             console.log(theme.system(t('status.dev', {
                 v: devMode ? t('common.on') : t('common.off'),
             })));
-            console.log(theme.system(t('status.max_iter', { v: maxIter })));
+            console.log(theme.system(t('status.max_iter', { v: currentMaxIter() })));
             console.log(theme.system(t('status.headless', { v: headless ? yes : no })));
             console.log(theme.system(t('status.debug', { v: debug ? yes : no })));
             const statusToggles = browser.getToggleStatesSync();
@@ -2848,6 +3203,53 @@ async function main() {
             }
             continue;
         }
+        if (lower === '/copy-code' || lower.startsWith('/copy-code ')) {
+            const arg = trimmed.slice('/copy-code'.length).trim();
+            const blocks = extractCodeBlocks(lastAssistantMessage ?? '');
+            if (!blocks.length) {
+                console.log(theme.dim(t('copy.no_code')));
+                continue;
+            }
+            if (arg === 'list') {
+                console.log(theme.system(t('copy_code.list')));
+                for (const b of blocks) {
+                    console.log(theme.assistant(t('copy_code.item', {
+                        n: String(b.index),
+                        lang: b.lang || 'text',
+                        lines: String(b.text.split(String.fromCharCode(10)).length),
+                    })));
+                }
+                continue;
+            }
+            // Prefer the TUI copy path (it reports into the log); fall back to a
+            // direct clipboard write for the legacy editor / non-TTY.
+            const n = arg ? Number(arg) : undefined;
+            if (n !== undefined && (!Number.isInteger(n) || n < 1)) {
+                console.log(theme.warn(t('copy.bad_index', { n: arg })));
+                continue;
+            }
+            if (editor &&
+                'copyCode' in editor &&
+                typeof editor.copyCode === 'function') {
+                editor.copyCode(n);
+                continue;
+            }
+            const pick = n !== undefined
+                ? blocks.find((b) => b.index === n)
+                : blocks[blocks.length - 1];
+            if (!pick) {
+                console.log(theme.warn(t('copy.bad_index', { n: String(n) })));
+                continue;
+            }
+            const res2 = writeClipboardText(pick.text);
+            if (res2.ok) {
+                console.log(theme.assistant(t('copy.done', { tool: res2.via })));
+            }
+            else {
+                console.error(theme.warn(t('copy.failed', { tool: res2.via })));
+            }
+            continue;
+        }
         if (lower === '/retry') {
             if (!lastTaskText) {
                 console.log(theme.dim(t('retry.none')));
@@ -3351,13 +3753,16 @@ async function main() {
             }
             continue;
         }
+        // A `/goal <condition>` turn is injected directly: skip the slash-command
+        // resolution (the text is NOT a command) and use the override as the task.
+        const isGoalOverride = taskOverride !== null;
         // Custom command or skill invoked as a slash command? Expand it into a
         // task. Skills are instructions the agent follows; custom commands are
         // prompt templates with $ARGUMENTS / {{args}} placeholders.
         let expandedTask = null;
         let missingArgs = null;
         let skillAllowedTools = null;
-        if (lower.startsWith('/')) {
+        if (lower.startsWith('/') && !isGoalOverride) {
             const name = trimmed.slice(1).split(/\s+/)[0];
             const rest = trimmed.slice(1 + name.length).trim();
             const res = await expandSlashTarget(currentWorkdir, name, rest);
@@ -3376,12 +3781,16 @@ async function main() {
             console.error(theme.error(t('msg.missing_args', { v: missingArgs.join(', ') })));
             continue;
         }
-        if (lower.startsWith('/') && expandedTask === null) {
+        if (lower.startsWith('/') && expandedTask === null && !isGoalOverride) {
             console.error(theme.error(t('msg.unknown_cmd', { v: trimmed })));
             continue;
         }
         // ---- Regular task (including in review mode) ----
-        const taskText = expandedTask !== null ? expandedTask : trimmed;
+        const taskText = isGoalOverride
+            ? taskOverride
+            : expandedTask !== null
+                ? expandedTask
+                : trimmed;
         // B5: inline any `@path` references into the task so the agent does not
         // spend a round-trip reading a file the operator already pointed at. Only
         // existing files are inlined; a bare `@name` in prose is left untouched.
@@ -3506,6 +3915,19 @@ async function main() {
                 contextLimit: config.ui.contextLimit,
                 getTokenUsage: () => browser.getLastTokenUsage(),
                 goal: sessionGoal,
+                // Completion-goal mode (Claude Code parity): the goal is a CONDITION,
+                // judged by a fresh model after each turn; while NOT met the loop
+                // keeps working. goalQuery re-reads sessionGoal so a mid-run
+                // `/goal clear` stops the auto-continuation immediately.
+                goalIsCondition: true,
+                goalQuery: () => sessionGoal,
+                onGoalCleared: async () => {
+                    // The evaluator ended the goal (MET or IMPOSSIBLE). Clear the
+                    // persisted condition so it does not re-arm on the next task; the
+                    // run-task loop already surfaced the verdict line to the operator.
+                    sessionGoal = null;
+                    await saveGoal(currentWorkdir, null);
+                },
                 todosQuery: () => todosSummary(),
                 selfImprovement: devMode,
                 onSubagent: makeSubagentRunner(),