zames_pro 2.73.11 → 2.75.0

package/CHANGELOG.md

@@ -7,6 +7,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.75.0] - 2026-10-14
+
+### Added
+
+- **tui:** show a one-time hint about mouse selection
+- **tui:** Home/End jump to the top/bottom of the dialog
+- **tui:** mouse wheel scrolls the dialog by default
+
+### Fixed
+
+- **tui:** the status row keeps its height (inline caret on the input row)
+- **tui:** the status bar never wraps to a second line
+- **tui:** the caret lands correctly in a CJK buffer
+- **tui:** responsive dividers and wrapping-aware menu window
+- **tui:** log scroll reads the LIVE offset (no stale closure)
+- **tui:** Ctrl+Delete works (kitty CSI-u) and deletes left at end of line
+- **tui:** the mouse wheel no longer scrolls the input history (for good)
+- **attachments:** keep the items array identity across reset()
+- **tui:** the config menu now redraws on change and fits the terminal
+- **tui:** reserve the real number of rows for a wrapping suggest popup
+- **tui:** exact badge width (T0.7) and honor NO_COLOR (T0.11)
+- **tui:** deliver the FULL pasted text to the agent, not the [Pasted lines#N] marker
+- **tui:** separate SELECT/SCROLL mouse modes and stop the header wrapping the panel
+
+## [2.74.0] - 2026-10-13
+
+### Added
+
+- **tui:** interactive /chats and /sessions list menus
+- **tui:** task progress bar and tool-result outcome icons (TUI-12)
+- **tui:** in-TUI login and one-time-code forms (TUI-10)
+- **tui:** copy code blocks (Ctrl+Y / /copy-code) and a CodeBlock widget
+- **tui:** Ink-based terminal UI with full-screen mode, rich menus and mouse scrolling
+- **goal:** completion-condition semantics with evaluator; make /config live
+
+### Fixed
+
+- **tui:** the mouse wheel now scrolls the DIALOG (not the input history)
+- **tui:** window the full-screen log by rendered ROW, not by entry
+- **tui:** split-safe wheel parser, empty-log hint, selection-aware suggest window
+- **tui:** real visual-row input box height, Ctrl+J, and wheel-vs-history
+- **tui:** multi-line input, growing input box, optional mouse scroll
+
+### Changed
+
+- **tui:** drop the task progress bar — keep just the "tasks: n/m" text
+- **tui:** distinct color and a divider for operator messages
+
 ## [2.73.11] - 2026-10-12
 
 ### Fixed

package/README.md

@@ -255,6 +255,18 @@ The prompt is a small line editor with persistent history:
   Claude Code's bash mode). The same sandbox guard as the `Bash` tool applies,
   so a direct command cannot leave the project either.
 
+Full-screen mode adds dialog navigation, so a long answer can be read and
+selected without leaving the terminal:
+
+- mouse wheel — scroll the dialog (never the input history; history is arrow
+  keys only). Selecting text needs `Shift`+drag, the standard TUI convention.
+- `PgUp` / `PgDn` — scroll the dialog half a screen.
+- `Home` / `End` — jump to the very top / bottom of the dialog (only while the
+  input line is empty; with text typed they move the caret as usual).
+- To copy a LARGE block, use `/export` (writes the whole session as Markdown)
+  or the transcript file (`/transcript` shows the path) — the terminal's own
+  drag-select cannot reach past one screen.
+
 Set `NO_COLOR=1` to disable colors (a calm default palette is used otherwise).
 
 ### Images and files
@@ -375,9 +387,12 @@ Codex CLI:
 - /compact — ask the active backend to compress the current chat into a handover
   summary, then open a NEW chat, resend the system prompt and post the summary
   as the carried-over context. Use it when the context gets long.
-- /goal [text|clear] — set a long-lived session goal. It is prepended to every
-  task message, so the model keeps the big picture across many turns. Stored in
-  `<project>/.zames-goal` (git-ignored) and restored on the next launch.
+- /goal <condition> — set a **completion condition** (Claude Code parity). The
+  agent starts working toward it at once and keeps starting new turns until a
+  separate evaluator model judges the condition met. The goal clears itself
+  automatically when it is met (or judged impossible), or with `/goal clear`.
+  The condition is stored in `<project>/.zames-goal` (git-ignored) and restored
+  on the next launch. `/goal` with no argument shows the current state.
 - /loop <interval> <task> — repeat a task periodically (e.g. `/loop 10m run the
 tests`). /cron "<min> <hour> <dom> <month> <dow>" <task> — run on a schedule.
   /jobs [rm <id>|clear] lists and stops them. A fired job is put into the same
@@ -820,6 +835,18 @@ zames
   Claude Code). Действует та же песочница, что и для инструмента `Bash`, так
   что прямая команда тоже не может выйти за пределы проекта.
 
+В полноэкранном режиме добавляется навигация по диалогу, чтобы длинный ответ
+можно было прочитать и выделить не покидая терминал:
+
+- колесо мыши — скролл диалога (историю ввода колесо НЕ листает; история —
+  только стрелки). Выделение текста — `Shift`+протяжка, стандарт TUI.
+- `PgUp` / `PgDn` — листать диалог на пол-экрана.
+- `Home` / `End` — прыжок в самый верх / низ диалога (только когда строка ввода
+  пуста; при набранном тексте они двигают курсор, как обычно).
+- Чтобы скопировать БОЛЬШОЙ кусок, используйте `/export` (пишет всю сессию в
+  Markdown) или файл транскрипта (`/transcript` покажет путь) — собственным
+  выделением терминала за пределы одного экрана не выделить.
+
 Установите `NO_COLOR=1`, чтобы отключить цвета (иначе используется спокойная
 палитра по умолчанию).
 
@@ -942,10 +969,13 @@ zames --task "..." --output-format jsonl \
 - /compact — попросить активный бэкенд сжать текущий чат в передаточное резюме,
   затем открыть НОВЫЙ чат, заново отправить системный промпт и положить резюме как
   перенесённый контекст. Используйте, когда контекст разрастается.
-- /goal [text|clear] — задать долгоживущую цель сессии. Она добавляется в
-  начало каждого сообщения задачи, поэтому модель держит общую картину через
-  много ходов. Хранится в `<project>/.zames-goal` (git-ignored) и
-  восстанавливается при следующем запуске.
+- /goal <условие> — задать **условие завершения** (как в Claude Code). Агент
+  сразу начинает работать над ним и продолжает запускать новые ходы, пока
+  отдельная модель-оценщик не признает условие выполненным. Цель снимается
+  автоматически при достижении (или если оценщик признал её недостижимой),
+  либо командой `/goal clear`. Условие хранится в `<project>/.zames-goal`
+  (git-ignored) и восстанавливается при следующем запуске. `/goal` без
+  аргумента показывает текущее состояние.
 - /loop <interval> <task> — повторять задачу периодически (например,
   `/loop 10m run the tests`). /cron "<min> <hour> <dom> <month> <dow>" <task> —
   запуск по расписанию. /jobs [rm <id>|clear] перечисляет и останавливает их.

package/dist/attachments.js

@@ -141,7 +141,12 @@ export class AttachmentStore {
     imageCount = 0;
     fileCount = 0;
     reset() {
-        this.items = [];
+        // Empty IN PLACE: the Ink tree captures `this.items` by reference at mount
+        // (InputLine's `attachments` prop). Reassigning to a new array left the
+        // tree holding the OLD one, so after the first submit every new attachment
+        // was appended to an array the UI no longer read — `onSubmit` got `[]` and
+        // the pasted image/file was silently dropped.
+        this.items.length = 0;
         this.imageCount = 0;
         this.fileCount = 0;
     }

package/dist/banner.js

@@ -0,0 +1,71 @@
+// The startup banner — a rounded box shown once at launch with the app name,
+// version, working directory and active provider. Pure string building (no
+// terminal access), so it is unit-testable and usable by both the TUI and the
+// non-TTY path.
+import { theme } from './theme.js';
+import { visLen } from './input/layout.js';
+/** Visible width of a string (ANSI stripped, wide chars counted as 2). */
+function width(s) {
+    return visLen(s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, ''));
+}
+/**
+ * Draw a rounded box around the given content lines. The box width is the
+ * widest line (clamped to `maxWidth`), padded by one space each side. Lines
+ * longer than the inner width are truncated with an ellipsis.
+ */
+function box(lines, maxWidth, border = '#c8b06a') {
+    const inner = Math.max(10, Math.min(maxWidth - 4, Math.max(...lines.map(width)) + 2));
+    const top = theme.prompt('╭' + '─'.repeat(inner) + '╮');
+    const bottom = theme.prompt('╰' + '─'.repeat(inner) + '╯');
+    const body = lines.map((l) => {
+        // Truncate to the inner width so a long path never breaks the frame.
+        const maxContent = Math.max(0, inner - 2);
+        const clipped = clip(l, maxContent);
+        const w = width(clipped);
+        const pad = Math.max(0, inner - 1 - w);
+        return (theme.prompt('│') + ' ' + clipped + ' '.repeat(pad) + theme.prompt('│'));
+    });
+    void border;
+    return [top, ...body, bottom].join('\n');
+}
+/** Truncate an (ANSI-carrying) string to `max` visible columns. */
+function clip(s, max) {
+    if (width(s) <= max)
+        return s;
+    // The banner content has at most a couple of ANSI runs; drop the tail by
+    // visible width while keeping escape sequences intact.
+    let out = '';
+    let visible = 0;
+    let i = 0;
+    const esc = /\x1b\[[0-9;?]*[A-Za-z]/y;
+    while (i < s.length && visible < max - 1) {
+        esc.lastIndex = i;
+        const m = esc.exec(s);
+        if (m && m.index === i) {
+            out += m[0];
+            i += m[0].length;
+            continue;
+        }
+        const cp = s.codePointAt(i);
+        const ch = String.fromCodePoint(cp);
+        visible += cp >= 0x1100 ? 2 : 1;
+        if (visible > max - 1)
+            break;
+        out += ch;
+        i += ch.length;
+    }
+    return out + '…';
+}
+/**
+ * The full startup banner string. `contentWidth` is the target outer width
+ * (the terminal width minus a safety column).
+ */
+export function renderStartupBanner(info, contentWidth) {
+    const title = theme.assistant('  ' + info.title) + theme.dim('  v' + info.version);
+    const dir = theme.system('  cwd: ') + theme.dir(info.workdir);
+    const prov = theme.system('  provider: ') + theme.toggleOn(info.provider);
+    const lines = [title, dir, prov];
+    if (info.hint)
+        lines.push(theme.dim('  ' + info.hint));
+    return box(lines, contentWidth);
+}

package/dist/browser.js

@@ -1,5 +1,5 @@
 import { chromium, } from 'playwright';
-import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, } from './net-capture.js';
+import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, isFinishedWithAnswer, } from './net-capture.js';
 import { rewriteFailedAttachments } from './commands.js';
 import { awaitUploadPreview, readAttachBuffers } from './attach-flow.js';
 import { parseHistoryMessages, extractChatMessages, scrapeChatList, scrapeChatMessages, } from './browser-chats.js';
@@ -64,6 +64,9 @@ export class DeepSeekBrowser {
     // Called after a successful interactive login so index.ts can persist the
     // credentials into the user config (the browser does not write config).
     onAuthSave;
+    // TUI-injected interactive prompts; null falls back to readline/askPassword.
+    onLoginPrompt;
+    onMfaPrompt;
     _lastSentAt;
     // Timestamp of the last Continue click. Clicks send a `chat/continue`
     // request and used to bypass `_waitForSendSlot()` entirely — a run that
@@ -158,7 +161,7 @@ export class DeepSeekBrowser {
     // must be stripped (DeepSeek's CDN answers 403 to it); computed in the
     // constructor, overridable by an explicit UA in the options/config.
     userAgent;
-    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, thinkingExtraMs = 2000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, autoContinue = true, continueMinGapMs = 1500, deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
+    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, thinkingExtraMs = 2000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, autoContinue = true, continueMinGapMs = 1500, deepThinking = false, webSearch = true, auth, locale, onAuthSave, onLoginPrompt, onMfaPrompt, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -185,6 +188,8 @@ export class DeepSeekBrowser {
         };
         this.locale = locale || DEFAULT_LOCALE;
         this.onAuthSave = onAuthSave || null;
+        this.onLoginPrompt = onLoginPrompt || null;
+        this.onMfaPrompt = onMfaPrompt || null;
         this._lastSentAt = 0;
         this._lastContinueAt = 0;
         this._abort = false;
@@ -593,25 +598,41 @@ export class DeepSeekBrowser {
             return false;
         }
         console.log('\n' + theme.warn(this._t('auth.need_login')));
-        // Username via a normal readline question (echoed).
         let user = this.auth.username;
-        if (!user) {
-            const readline = await import('readline');
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-                terminal: true,
+        let password = this.auth.password;
+        if (this.onLoginPrompt) {
+            // TUI path: ONE Ink form for username + masked password (a readline
+            // question would pause the whole TUI and fight Ink for stdin).
+            const res = await this.onLoginPrompt({
+                savedUsername: this.auth.username,
+                hasSavedPassword: !!this.auth.password,
             });
-            user = (await new Promise((resolve) => rl.question(this._t('auth.prompt_login'), (a) => resolve(a)))).trim();
-            rl.close();
+            if (!res)
+                return false;
+            user = res.username.trim();
+            password = res.password;
+        }
+        else {
+            // Username via a normal readline question (echoed).
+            if (!user) {
+                const readline = await import('readline');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                    terminal: true,
+                });
+                user = (await new Promise((resolve) => rl.question(this._t('auth.prompt_login'), (a) => resolve(a)))).trim();
+                rl.close();
+            }
+            // Password via raw keystroke reading, echoed as `*` (readline would echo
+            // it in clear or swallow the prompt — see askPassword).
+            const passPromptKey = hasSaved
+                ? 'auth.prompt_password_saved'
+                : 'auth.prompt_password';
+            const pass = await askPassword(this._t(passPromptKey));
+            if (pass)
+                password = pass;
         }
-        // Password via raw keystroke reading, echoed as `*` (readline would echo
-        // it in clear or swallow the prompt — see askPassword).
-        const passPromptKey = hasSaved
-            ? 'auth.prompt_password_saved'
-            : 'auth.prompt_password';
-        const pass = await askPassword(this._t(passPromptKey));
-        const password = pass || this.auth.password;
         if (!user || !password)
             return false;
         console.log(theme.system(this._t('auth.auto_login')));
@@ -817,15 +838,22 @@ export class DeepSeekBrowser {
                 v: account || '—',
             })));
         const readline = await import('readline');
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            terminal: true,
-        });
-        const code = (await new Promise((resolve) => rl.question(this._t('auth.mfa_prompt'), (a) => resolve(a))))
-            .trim()
-            .replace(/\s+/g, '');
-        rl.close();
+        let code;
+        if (this.onMfaPrompt) {
+            // TUI path: the Ink form reads the code without pausing the whole UI.
+            code = ((await this.onMfaPrompt()) ?? '').trim().replace(/\s+/g, '');
+        }
+        else {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true,
+            });
+            code = (await new Promise((resolve) => rl.question(this._t('auth.mfa_prompt'), (a) => resolve(a))))
+                .trim()
+                .replace(/\s+/g, '');
+            rl.close();
+        }
         if (!code)
             return false;
         await this._setInputText(codeInput, code);
@@ -2006,6 +2034,9 @@ export class DeepSeekBrowser {
         const deadline = Date.now() + timeout;
         let last = '';
         let stable = 0;
+        // Ticks since the SSE body reported FINISHED-with-answer while the DOM
+        // heuristics kept the loop waiting (see the safety net below).
+        let netFinishedTicks = 0;
         while (Date.now() < deadline) {
             if (this._abort || this._askCancelled) {
                 return last || '(прервано пользователем)';
@@ -2089,6 +2120,32 @@ export class DeepSeekBrowser {
             // tool call" hang. If generation has clearly ENDED (no Stop button) and
             // the text is stable, accept it (even when it repeats the previous one).
             const sameAsBefore = !!cur && !isNew && normText(cur) === normText(beforeText);
+            // NETWORK-AUTHORITATIVE SAFETY NET. The DOM heuristics above
+            // (`isNew`/`sameAsBefore`/`_isGenerating`) can all be wrong at once on a
+            // resumed chat: the DOM may still show the PREVIOUS answer, the Stop
+            // button may linger, and `beforeText` may equal the fresh answer. The
+            // finish loop then waits out the whole askDeadlineMs while the spinner
+            // runs — the operator sees "generation is running but nothing happens"
+            // (reported from the live agent). The SSE body is the ground truth: if it
+            // says FINISHED **with** a RESPONSE fragment, the turn is over and the
+            // captured answer is complete. Return it after a short grace period so a
+            // genuinely still-streaming answer is never cut (the capture keeps
+            // growing until FINISHED).
+            const netFinishedWithAnswer = !!this._netCapture &&
+                this._netCaptureAt >= this._lastSentAt &&
+                isFinishedWithAnswer(this._netBody);
+            if (netFinishedWithAnswer) {
+                netFinishedTicks++;
+                // Two ticks (~2 x stabilityDelayMs) is enough for the final DOM/capture
+                // settle without risking a truncated answer.
+                if (netFinishedTicks >= 2) {
+                    this._askDebug('RETURN net-finished curLen=' + this._netCapture.length);
+                    return this._cleanAnswer(this._netCapture) || cur;
+                }
+            }
+            else {
+                netFinishedTicks = 0;
+            }
             if (isNew && cur === last) {
                 stable++;
                 // `stabilityChecks` / `stabilityDelayMs` are the real knobs here.

package/dist/code-blocks.js

@@ -0,0 +1,48 @@
+// PURE extraction of fenced code blocks from a Markdown answer.
+//
+// The TUI cannot offer a real "copy button", so copying a code block is bound
+// to a key / command. That needs the RAW fenced text (the highlighted render is
+// full of ANSI and must NOT be copied), which is what this module returns.
+// Kept pure so it is unit-tested without a terminal.
+/**
+ * Extract every fenced code block (``` or ~~~) from `md`, in order. Handles a
+ * longer closing fence than the opening one and an unterminated final block
+ * (the answer was truncated) — a half block is still copyable.
+ */
+export function extractCodeBlocks(md) {
+    const lines = String(md ?? '').split(String.fromCharCode(10));
+    const out = [];
+    let i = 0;
+    let n = 0;
+    while (i < lines.length) {
+        const m = /^(\s*)(`{3,}|~{3,})\s*([^`]*)$/.exec(lines[i]);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const fence = m[2];
+        const marker = fence[0];
+        const minLen = fence.length;
+        const lang = (m[3] || '').trim();
+        i++;
+        const body = [];
+        let closed = false;
+        while (i < lines.length) {
+            // A closing fence is the SAME marker, at least as long, with nothing
+            // else on the line (whitespace allowed).
+            const c = new RegExp('^\\s*' + marker + '{' + minLen + ',}\\s*$');
+            if (c.test(lines[i])) {
+                closed = true;
+                i++;
+                break;
+            }
+            body.push(lines[i]);
+            i++;
+        }
+        if (body.length === 0 && closed)
+            continue;
+        n++;
+        out.push({ lang, text: body.join(String.fromCharCode(10)), index: n });
+    }
+    return out;
+}

package/dist/commands.js

@@ -988,6 +988,7 @@ export const SLASH_COMMANDS = [
     { name: '/rename', key: 'help.cmd.rename' },
     { name: '/context', key: 'help.cmd.context' },
     { name: '/copy', key: 'help.cmd.copy' },
+    { name: '/copy-code', key: 'help.cmd.copy_code' },
     { name: '/chat', key: 'help.cmd.chat' },
     { name: '/cd', key: 'help.cmd.cd' },
     { name: '/pwd', key: 'help.cmd.pwd' },

package/dist/config-live.js

@@ -0,0 +1,53 @@
+// Live application of /config changes to the objects built ONCE at
+// startup (the browser, the undo/checkpoint stores). setConfigRuntime only
+// mutates the config object; these objects COPIED their values at
+// construction, so a change must be pushed onto the live instance too or it
+// is silently a no-op until a restart. The path->target mapping is PURE and
+// unit-tested here; index.ts wires it to the live instances.
+/** config path -> field name on the browser instance. Both backends
+ *  share these names; a field that is absent on the active backend
+ *  (e.g. DeepSeek-only thinkingExtraMs on Qwen) is skipped, not thrown. */
+export const BROWSER_LIVE_CONFIG = {
+    'browser.answerTimeoutMs': 'answerTimeoutMs',
+    'browser.askRetries': 'askRetries',
+    'browser.stabilityChecks': 'stabilityChecks',
+    'browser.stabilityDelayMs': 'stabilityDelayMs',
+    'browser.minSendIntervalMs': 'minSendIntervalMs',
+    'browser.thinkingExtraMs': 'thinkingExtraMs',
+    'browser.rateLimitWaitMs': 'rateLimitWaitMs',
+    'browser.maxRateLimitRetries': 'maxRateLimitRetries',
+    'browser.maxIncompleteRetries': 'maxIncompleteRetries',
+    'browser.incompleteWaitMs': 'incompleteWaitMs',
+    'browser.autoContinue': 'autoContinue',
+    'browser.continueMinGapMs': 'continueMinGapMs',
+    'browser.askDeadlineMs': 'askDeadlineMs',
+    'browser.maxAfterToolRetries': 'maxAfterToolRetries',
+};
+/** Push a browser.* change onto the live instance. Returns true when a
+ *  field was written (false = not a browser timing knob, or absent on this
+ *  backend). */
+export function applyBrowserLiveConfig(path, value, browser) {
+    const field = BROWSER_LIVE_CONFIG[path];
+    if (!field || !(field in browser))
+        return false;
+    browser[field] = value;
+    return true;
+}
+/** Push undo.* / checkpoint.* changes onto the live stores. The stores copy
+ *  their config at construction, so a change must be written to the instance
+ *  too. */
+export function applyStoreLiveConfig(path, value, stores) {
+    if (path === 'undo.enabled' || path === 'undo.maxBackups') {
+        if (!stores.undo)
+            return false;
+        stores.undo[path === 'undo.enabled' ? 'enabled' : 'maxBackups'] = value;
+        return true;
+    }
+    if (path === 'checkpoint.enabled' || path === 'checkpoint.maxBackups') {
+        if (!stores.checkpoints)
+            return false;
+        stores.checkpoints[path === 'checkpoint.enabled' ? 'enabled' : 'maxBackups'] = value;
+        return true;
+    }
+    return false;
+}

package/dist/config.js

@@ -89,6 +89,26 @@ export const DEFAULTS = {
         // N37 statusLine hook. Off by default; edit config.json to set a command.
         statusLineCommand: '',
         statusLineIntervalMs: 10_000,
+        // Use the Ink/React TUI for the input area (the rich editor). Set to false
+        // to fall back to the legacy hand-rolled LineEditor.
+        tui: true,
+        // Render the TUI in the terminal's alternate screen buffer (FULL-SCREEN
+        // mode, like Codex / Claude Code / opencode). This is the default because
+        // it is the only mode where a resize cannot leave ghost/duplicate lines:
+        // the whole screen belongs to the app and the terminal never reflows our
+        // output. The trade-off is that the terminal SCROLLBACK is not available
+        // (PgUp/PgDn scroll the in-app log instead). Set to false for the inline
+        // layout, which keeps the scrollback but is subject to reflow artifacts.
+        alternateScreen: true,
+        // In-app MOUSE-WHEEL scrolling of the log. ON by default: the operator
+        // asked that the wheel scroll the DIALOG (and it must NEVER scroll the
+        // input history — history is arrow keys only). That needs terminal mouse
+        // REPORTING (1000/1006) plus alternate-scroll OFF (1007l), so the wheel
+        // arrives as SGR events we consume and never as Up/Down arrows. The
+        // trade-off is that the terminal no longer does its own drag-select, so
+        // selecting text needs SHIFT+DRAG (the standard TUI convention). Set to
+        // false to give the terminal the mouse back (native select, wheel inert).
+        mouseScroll: true,
     },
     // Off by default: a full tsc/eslint run after every edit is slow; opt in.
     diagnostics: { ...DEFAULT_DIAGNOSTICS },
@@ -162,6 +182,24 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.ui_answerWidth',
         groupKey: 'cfg.group.ui',
     },
+    {
+        path: 'ui.tui',
+        type: 'boolean',
+        labelKey: 'cfg.f.ui_tui',
+        groupKey: 'cfg.group.ui',
+    },
+    {
+        path: 'ui.alternateScreen',
+        type: 'boolean',
+        labelKey: 'cfg.f.ui_alternateScreen',
+        groupKey: 'cfg.group.ui',
+    },
+    {
+        path: 'ui.mouseScroll',
+        type: 'boolean',
+        labelKey: 'cfg.f.ui_mouseScroll',
+        groupKey: 'cfg.group.ui',
+    },
     {
         path: 'headless',
         type: 'boolean',

package/dist/goal.js

@@ -0,0 +1,81 @@
+// Completion-goal semantics (Claude Code parity). A /goal sets a CONDITION
+// that must be satisfied; after every turn a fresh model judges it (MET ->
+// clear, IMPOSSIBLE -> clear, NOT_MET -> keep working). The PURE half -- the
+// evaluator prompt and the verdict parser -- lives here so it is unit-tested
+// without a browser. The `browser.ask()` call and the continuation loop live
+// in run-task.ts.
+/** Hard cap on the condition length, mirroring Claude Code's 4 000-char bound. */
+export const GOAL_CONDITION_CAP = 4000;
+/** Default cap on how many auto-continue turns a goal may spawn. */
+export const GOAL_MAX_TURNS = 25;
+/** Trim a goal condition to the cap. */
+export function clampGoalCondition(condition) {
+    const g = String(condition ?? '').trim();
+    if (g.length <= GOAL_CONDITION_CAP)
+        return g;
+    return g.slice(0, GOAL_CONDITION_CAP);
+}
+// The evaluator prompt is AGENT-facing (English), like the system prompt and
+// the compact summary prompt. It runs in the SAME chat as the work so the
+// judge sees the actual transcript (command output, file state), which is
+// what Claude Code's evaluator reads too. A clean, machine-parsable verdict
+// is requested; no tools.
+export function buildEvaluatorPrompt(condition) {
+    const NL = String.fromCharCode(10);
+    return ('You are a strict COMPLETION EVALUATOR. You do NOT do the work and you do NOT call tools. Read ' +
+        'the conversation above and judge - from what the agent has ALREADY surfaced - whether ' +
+        'the completion condition below is satisfied.' +
+        NL +
+        NL +
+        'Completion condition:' +
+        NL +
+        condition +
+        NL +
+        NL +
+        'Reply with EXACTLY two lines, nothing else:' +
+        NL +
+        'VERDICT: MET | NOT_MET | IMPOSSIBLE' +
+        NL +
+        'REASON: <one short sentence>' +
+        NL +
+        NL +
+        'Rules:' +
+        NL +
+        '- MET only if the condition is demonstrably satisfied: evidence appears in the conversation ' +
+        '(command output, test result, file state). A promise to do it later is NOT MET.' +
+        NL +
+        '- NOT_MET if more work is needed; state briefly what is missing.' +
+        NL +
+        '- IMPOSSIBLE only if the condition can never be satisfied as written.' +
+        NL +
+        '- Judge from the conversation only; do not run commands or read files independently.');
+}
+// The continuation directive injected as the next turn's task when the
+// evaluator says NOT_MET. Agent-facing (English). The goal itself is prepended
+// again by withGoal(), so this only adds the verdict + a continue instruction.
+export function buildContinuationDirective(reason) {
+    const NL = String.fromCharCode(10);
+    return ('The completion goal is NOT yet met. Continue working toward it ' +
+        'until it is satisfied. Do not call respond with a final summary until the ' +
+        'condition is met.' +
+        NL +
+        (argumentReason(reason) ? 'Evaluator note: ' + reason : ''));
+}
+function argumentReason(reason) {
+    return String(reason ?? '').trim().length > 0;
+}
+// Parse the evaluator's reply into a verdict. Tolerant of markdown emphasis
+// and casing (```VErdict: MET``). Returns null when the verdict line is
+// missing, so the caller can fail closed (treat an unparsable answer as
+// "continue", never as "done").
+export function parseGoalVerdict(text) {
+    const t = String(text ?? '');
+    const m = /VERDICT:\s*(`{0,3})?\s*(MET|NOT_MET|IMPOSSIBLE)/i.exec(t);
+    if (!m)
+        return null;
+    const raw = m[2].toUpperCase();
+    const status = raw === 'MET' ? 'met' : raw === 'IMPOSSIBLE' ? 'impossible' : 'not_met';
+    const rm = /REASON:\s*(.+)/i.exec(t);
+    const reason = rm ? rm[1].replace(/`{2,}/g, '').trim() : '';
+    return { status, reason };
+}