zames_pro 2.73.10 → 2.74.0

package/dist/input/layout.js

@@ -227,6 +227,25 @@ export function truncateToWidth(s, maxCols) {
     }
     return out + '…';
 }
+// Inner content width of the framed input box: the rounded border takes 1
+// column on each side and the box adds 1 column of padding on each side, so
+// the text must wrap to `cols - 4`. Exported so the layout ABOVE the box
+// (FullScreenApp) and the box itself (InputLine) use ONE number — a mismatch
+// made the reserved height disagree with the rendered rows and the panel
+// overflowed.
+export function inputInnerCols(cols) {
+    return Math.max(4, (Number(cols) || 80) - 4);
+}
+// Real height (rows) of the framed input box for the CURRENT buffer: 2 border
+// rows + the number of VISUAL rows the buffer wraps to. Using the LOGICAL line
+// count (buf.split('\n').length) was wrong: a long line wraps and renders MORE
+// rows than it has newlines, so the box was reserved too few rows, the second
+// line printed OVER the first and the cursor landed on the wrong row.
+export function inputBoxRows(prompt, buf, cursor, cols) {
+    const inner = inputInnerCols(cols);
+    const rows = layoutInput(prompt, buf, cursor, inner).rows.length;
+    return 2 + Math.max(1, rows);
+}
 export function layoutInput(promptStr, buf, cursor, cols) {
     // Reserve the LAST column. If a printed row reaches exactly `cols` columns,
     // terminals with autowrap (Tabby, iTerm, Windows Terminal, xterm's default

package/dist/input/suggest.js

@@ -57,6 +57,19 @@ export function suggestWindow(sugg, offset) {
     const moreCount = sugg.length > pageSize ? sugg.length - shown.length : 0;
     return { shown, off, moreCount };
 }
+/**
+ * How many terminal ROWS the suggestion popup occupies for the current buffer
+ * (0 when no list). Full-screen mode uses this to RESERVE space above the
+ * input panel so opening the list does not shift the layout (the operator saw
+ * the whole screen jump when `/chats` or `/resume` hints appeared).
+ */
+export function suggestRowCount(buf, commands) {
+    const sugg = matchSlashCommands(buf, commands);
+    if (!sugg.length)
+        return 0;
+    const { moreCount } = suggestWindow(sugg, 0);
+    return Math.min(sugg.length, SUGGEST_PAGE) + (moreCount > 0 ? 1 : 0);
+}
 /**
  * Tab completion. With an explicit selection, insert that command. With a
  * single match, insert it whole. Otherwise complete up to the longest common

package/dist/input.js

@@ -1,4 +1,5 @@
 import { theme, divider } from './theme.js';
+import { summarizeToolCall } from './tool-summary.js';
 import { renderMarkdown } from './markdown.js';
 import { contentWidth } from './width.js';
 import { randomThinkingPhrase, stripEllipsis, DOTS, renderDots, } from './spinner.js';
@@ -940,6 +941,10 @@ export class LineEditor {
         this.statusText = text || '';
         this._render();
     }
+    // No-op success/failure hooks, kept so LineEditor satisfies the shared
+    // UiEditor interface (the TUI and the spinner expose the same surface).
+    succeed() { }
+    fail() { }
     _stopDots() {
         if (this._dotTimer) {
             clearInterval(this._dotTimer);
@@ -1070,8 +1075,11 @@ export class LineEditor {
         // wider than the terminal and some terminals then showed a horizontal
         // scrollbar. Keep one column free (autowrap safety), same as the status.
         const maxW = contentWidth();
-        const preview = truncateToWidth(full, maxW);
-        this.printAbove(theme.tool('🔧 ' + name) + ' ' + theme.dim(preview));
+        const summary = summarizeToolCall(name, (typeof args === 'object' && args !== null ? args : {}));
+        const detail = summary.detail
+            ? truncateToWidth(summary.detail, Math.max(10, maxW - name.length - 6))
+            : truncateToWidth(full, maxW);
+        this.printAbove(theme.tool('🔧 ' + name) + (detail ? theme.dim('(' + detail + ')') : ''));
         // A tool may run for a long time (Bash, npm test, MCP). Without an active
         // animation the operator sees a frozen screen and cannot tell work is in
         // progress. Start the animated status AFTER printAbove (which stops the
@@ -1186,7 +1194,10 @@ export class LineEditor {
         // Attachments collected for this message (images/files). They are handed
         // to the browser layer to be attached to the chat.
         const attached = this.attachments.items.slice();
-        this.printAbove(theme.user('❯ ') + wrapToWidth(display, contentWidth()));
+        // A turn separator + a BAR-marked operator message (same look as the TUI).
+        this.printAbove(theme.turnRule('─'.repeat(contentWidth())));
+        this.printAbove(theme.userBar('▌ ') +
+            theme.user(wrapToWidth(display, contentWidth() - 2)));
         this.pastes = [];
         this.attachments.reset();
         if (this.onSubmit)

package/dist/net-capture.js

@@ -186,6 +186,24 @@ export function isFinishedWithoutAnswer(body) {
     // absence of response content as "no answer produced".
     return true;
 }
+/**
+ * True when the SSE body shows a turn that ENDED (`quasi_status: FINISHED`)
+ * AND carried a non-empty RESPONSE fragment — i.e. the server is done and the
+ * answer is COMPLETE. This is the network-authoritative "the turn is over"
+ * signal: the finish loop can trust it to stop waiting even when the DOM
+ * heuristics (`isNew`/`_isGenerating`) are confused (a resumed chat, a stale
+ * Stop button, a DOM that never caught up). Without it the loop waited out
+ * the whole askDeadlineMs while showing a spinner — the "generation is running
+ * but nothing happens" hang.
+ */
+export function isFinishedWithAnswer(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    if (!FINISHED_STATUS_RE.test(b))
+        return false;
+    return RESPONSE_CONTENT_RE.test(b);
+}
 // The CONTEXT size (in tokens) DeepSeek reports for the current answer.
 //
 // chat.deepseek.com does not expose prompt_tokens/completion_tokens the way

package/dist/qwen-browser.js

@@ -79,6 +79,7 @@ export class QwenBrowser {
     auth;
     locale;
     onAuthSave;
+    onLoginPrompt;
     // Watchdog budget the agent loop reads (same contract as DeepSeekBrowser).
     maxAfterToolRetries;
     askDeadlineMs;
@@ -121,7 +122,7 @@ export class QwenBrowser {
     onSendState;
     onNotice;
     userAgent;
-    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, startWaitMs = 30000, sendButtonWaitMs = 8000, model = '', deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
+    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, startWaitMs = 30000, sendButtonWaitMs = 8000, model = '', deepThinking = false, webSearch = true, auth, locale, onAuthSave, onLoginPrompt, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -148,6 +149,7 @@ export class QwenBrowser {
         };
         this.locale = locale || DEFAULT_LOCALE;
         this.onAuthSave = onAuthSave || null;
+        this.onLoginPrompt = onLoginPrompt || null;
         this.maxAfterToolRetries = 6;
         this.askDeadlineMs = answerTimeoutMs + 60000;
         this._lastSentAt = 0;
@@ -574,31 +576,52 @@ export class QwenBrowser {
     // This is the DEFAULT Qwen flow (no password needed).
     async _promptAndLogin() {
         await this._openLoginPage();
-        const readline = await import('readline');
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const email = await new Promise((resolve) => rl.question(this._t('qwen.login_email_prompt', {
-            def: this.auth.username ? ' [' + this.auth.username + ']' : '',
-        }), resolve));
-        rl.close();
-        const addr = email.trim() || this.auth.username;
-        if (!addr) {
-            this._notice(this._t('qwen.login_failed'));
-            return false;
+        let addr;
+        let code;
+        if (this.onLoginPrompt) {
+            // TUI path: the Ink prompt reads the email/code without pausing Ink.
+            const email = await this.onLoginPrompt({
+                savedUsername: this.auth.username,
+                step: 'email',
+            });
+            addr = (email ?? '').trim() || this.auth.username;
+            if (!addr) {
+                this._notice(this._t('qwen.login_failed'));
+                return false;
+            }
+            const codeAns = await this.onLoginPrompt({
+                savedUsername: addr,
+                step: 'code',
+            });
+            code = (codeAns ?? '').trim();
         }
-        let ok;
-        try {
-            await this._fillEmailAndContinue(addr);
-            await this.page.waitForTimeout(1500);
+        else {
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const email = await new Promise((resolve) => rl.question(this._t('qwen.login_email_prompt', {
+                def: this.auth.username ? ' [' + this.auth.username + ']' : '',
+            }), resolve));
+            rl.close();
+            addr = email.trim() || this.auth.username;
+            if (!addr) {
+                this._notice(this._t('qwen.login_failed'));
+                return false;
+            }
             const rlCode = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout,
             });
-            const code = await new Promise((resolve) => rlCode.question(this._t('qwen.login_code_prompt'), resolve));
+            code = (await new Promise((resolve) => rlCode.question(this._t('qwen.login_code_prompt'), resolve))).trim();
             rlCode.close();
-            await this._submitCode(code.trim());
+        }
+        let ok;
+        try {
+            await this._fillEmailAndContinue(addr);
+            await this.page.waitForTimeout(1500);
+            await this._submitCode(code);
             ok = await this._waitLoggedIn(30000);
         }
         catch (e) {

package/dist/run-task.js

@@ -1,14 +1,35 @@
 import { theme } from './theme.js';
 import { withGoal, mergeMessages, isSlashCommand, formatDuration, } from './commands.js';
+import { buildEvaluatorPrompt, buildContinuationDirective, parseGoalVerdict, GOAL_MAX_TURNS, } from './goal.js';
 import { formatCompactTokens, pasteReplacement, expandPastes } from './input.js';
 import { providerAskDeadlineMs } from './config.js';
 // Ask the operator to approve a tool call flagged by an `ask` permission rule
 // (C1). While the LineEditor owns the terminal it must be paused first, or the
 // confirmation prompt and the input line fight for the same keys. A non-TTY run
 // has no way to answer, so it DENIES (never silently allows a guarded call).
-export async function askOperatorConfirm(editor, question) {
+export async function askOperatorConfirm(editor, question, t) {
     if (!(process.stdin.isTTY && process.stdout.isTTY))
         return false;
+    // Prefer the Ink modal when the TUI owns the terminal: it keeps the layout
+    // and does not pause/restart the whole editor.
+    if (editor && 'isTui' in editor && editor.isTui) {
+        if (editor.pause)
+            editor.pause();
+        try {
+            const { askConfirmInk } = await import('./tui/run-confirm.js');
+            const tr = t ?? ((k) => k);
+            return await askConfirmInk({
+                title: tr('perm.title'),
+                message: question,
+                yesLabel: tr('confirm.yes'),
+                noLabel: tr('confirm.no'),
+            });
+        }
+        finally {
+            if (editor.resume)
+                editor.resume();
+        }
+    }
     if (editor)
         editor.pause();
     try {
@@ -236,9 +257,34 @@ export function watchInput({ onEscape, onChange, onQueue, } = {}) {
             stdin.setRawMode(wasRaw || false);
     };
 }
+// Run the completion-goal evaluator: one model call in the SAME chat that
+// judges the condition against the transcript. Returns null when the call
+// fails or the reply is unparsable (the caller then fails CLOSED and keeps
+// working — an unreadable verdict must never be mistaken for "met").
+// `agent: true` so it waits out the send throttle like any other agent turn.
+async function evaluateGoal(browser, condition, config, transcript) {
+    try {
+        const raw = await browser.ask(buildEvaluatorPrompt(condition), {
+            agent: true,
+            timeout: providerAskDeadlineMs(config),
+        });
+        transcript?.log('goal_eval_raw', { response: raw.slice(0, 500) });
+        return parseGoalVerdict(raw);
+    }
+    catch (e) {
+        transcript?.log('goal_eval_error', { error: e.message });
+        return null;
+    }
+}
 export async function runTask(deps, browser, tools, taskText, workdir, opts, attachments = []) {
     const { t, locale, debug, maxIter, config, runAgentLoop, createSpinner } = deps;
-    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, todosQuery = null, selfImprovement = false, onSubagent = null, } = opts;
+    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, goalIsCondition = false, onGoalCleared = null, goalMaxTurns = GOAL_MAX_TURNS, goalQuery = null, todosQuery = null, selfImprovement = false, onSubagent = null, } = opts;
+    // The ACTIVE goal for the duration of this run. It is mutable because a
+    // completion goal can be cleared mid-run (verdict MET/IMPOSSIBLE, or the
+    // operator runs `/goal clear` while the task is in flight). `goalQuery`
+    // re-reads the operator's current goal so a mid-run clear stops the loop.
+    let activeGoal = goal;
+    const currentGoal = () => goalQuery ? goalQuery() : activeGoal;
     // In TTY mode the UI is a LineEditor: it owns the input (queue, Esc,
     // Ctrl+C) and draws the status ABOVE the permanent input line. In non-TTY
     // mode (pipes) - a regular spinner + watchInput.
@@ -282,6 +328,8 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
         let failure = null;
         // N31: the machine-readable reason for the last task's outcome.
         let outcomeKind = 'ok';
+        // How many auto-continue turns a completion goal has already spent.
+        let goalTurns = 0;
         let next = {
             text: taskText,
             attachments,
@@ -307,7 +355,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
             const outcome = await runAgentLoop({
                 browser,
                 tools,
-                task: withGoal(goal, next.text),
+                task: withGoal(currentGoal(), next.text),
                 workdir,
                 maxIterations: maxIter,
                 freshChat: next.freshChat,
@@ -338,7 +386,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                     // C1: a rule with action "ask". Show the reason and wait for the
                     // operator. In non-TTY this denies.
                     ui.warning(t('perm.ask', { tool: info.tool, reason: info.reason }));
-                    const ok = await askOperatorConfirm(editor || null, t('perm.confirm'));
+                    const ok = await askOperatorConfirm(editor || null, t('perm.confirm'), t);
                     ui.warning(ok ? t('perm.allowed') : t('perm.denied'));
                     transcript?.log('permission_ask', {
                         tool: info.tool,
@@ -407,6 +455,51 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 editor.printAbove(summary);
             else
                 console.log(summary);
+            // Completion goal (Claude Code parity): after EVERY turn a fresh model
+            // judges the condition. NOT_MET starts another turn automatically instead
+            // of returning control to the operator; MET/IMPOSSIBLE ends the goal.
+            // The evaluation runs only when the operator queue is EMPTY, so a message
+            // typed mid-run is always delivered before the next auto-continue turn.
+            if (!browser._stopped && goalIsCondition && !queue.length) {
+                const cond = currentGoal();
+                if (cond) {
+                    if (goalTurns >= goalMaxTurns) {
+                        ui.warning(t('goal.turn_budget', { n: String(goalMaxTurns) }));
+                        transcript?.log('goal_turn_budget', { turns: goalTurns });
+                        break;
+                    }
+                    const verdict = await evaluateGoal(browser, cond, config, transcript);
+                    goalTurns++;
+                    if (verdict && verdict.status === 'met') {
+                        ui.warning(t('goal.met', { reason: verdict.reason }));
+                        transcript?.log('goal_met', { reason: verdict.reason });
+                        activeGoal = null;
+                        if (onGoalCleared)
+                            await onGoalCleared(verdict);
+                        break;
+                    }
+                    if (verdict && verdict.status === 'impossible') {
+                        ui.warning(t('goal.impossible', { reason: verdict.reason }));
+                        transcript?.log('goal_impossible', { reason: verdict.reason });
+                        activeGoal = null;
+                        if (onGoalCleared)
+                            await onGoalCleared(verdict);
+                        break;
+                    }
+                    // NOT_MET (or an unparsable verdict -> fail closed as "continue"):
+                    // start another turn with the continuation directive as the task.
+                    const reason = verdict?.reason ?? '';
+                    if (reason)
+                        ui.warning(t('goal.progress', { reason }));
+                    transcript?.log('goal_not_met', { reason, turn: goalTurns });
+                    next = {
+                        text: buildContinuationDirective(reason),
+                        freshChat: false,
+                        sendSystemPrompt: false,
+                    };
+                    continue;
+                }
+            }
             // Aborted (Esc/Ctrl+C) - we don't start the next tasks from the queue and
             // clear it, so "stop" really stops everything.
             if (browser._stopped) {

package/dist/theme.js

@@ -16,7 +16,13 @@ import { contentWidth } from './width.js';
 //   - warn        — calm ochre
 //   - error       — muted terracotta
 export const theme = {
-    user: chalk.hex('#b4b8d0'), // soft lavender-gray
+    // Operator messages — a clearly DISTINCT cyan so they never blend with the
+    // model's warm-sand answers or the neutral system text (operator request).
+    user: chalk.hex('#8fd4f0'), // operator text — bright cyan-blue
+    userBar: chalk.hex('#4a8fb5'), // the `▌` bar marking an operator turn
+    // A dim rule + label separating one conversation TURN from the next.
+    turnRule: chalk.hex('#3a3f4b'),
+    turnLabel: chalk.hex('#5b616e'),
     prompt: chalk.hex('#c8b06a').bold, // input prompt — warm gold, noticeable
     dir: chalk.hex('#7fc4f0'), // working directory name — noticeably blue
     assistant: chalk.hex('#cfc9b0'), // warm sand

package/dist/tool-summary.js

@@ -0,0 +1,83 @@
+// PURE tool-call summarizer — turns a tool's raw args into a SHORT, readable
+// one-liner for the log (Codex / Claude Code style): `Read(src/index.ts)`
+// instead of the full JSON. No terminal access, so it is unit-testable.
+//
+// The full args are NOT lost: when a tool has no special summary the caller
+// still shows the raw JSON, so nothing is hidden.
+/** Collapse whitespace and clip to `max` chars (single line). */
+function oneLine(s, max = 80) {
+    const t = String(s).replace(/\s+/g, ' ').trim();
+    return t.length > max ? t.slice(0, max - 1) + '…' : t;
+}
+function str(v) {
+    return typeof v === 'string' ? v : '';
+}
+/**
+ * A compact, human-readable summary of a tool call. Falls back to the JSON of
+ * the args when there is nothing specific to show, so no information is lost.
+ */
+export function summarizeToolCall(name, args) {
+    const a = args || {};
+    switch (name) {
+        case 'Read':
+        case 'Write':
+        case 'Edit':
+        case 'MultiEdit':
+            return { name, detail: oneLine(str(a.path) || str(a.file_path)) };
+        case 'LS':
+        case 'Glob':
+            return {
+                name,
+                detail: oneLine(str(a.path) || str(a.pattern) || '.'),
+            };
+        case 'Grep':
+            return {
+                name,
+                detail: oneLine((str(a.pattern) ? '/' + str(a.pattern) + '/' : '') +
+                    (a.path ? ' ' + str(a.path) : '')),
+            };
+        case 'Bash': {
+            const cmd = str(a.command);
+            return { name, detail: oneLine(cmd) };
+        }
+        case 'Task':
+            return { name, detail: oneLine(str(a.description) || str(a.prompt)) };
+        case 'TodoWrite': {
+            const todos = Array.isArray(a.todos) ? a.todos.length : 0;
+            return { name, detail: todos ? todos + ' items' : '' };
+        }
+        case 'respond':
+            return { name, detail: oneLine(str(a.message), 60) };
+        default: {
+            const keys = Object.keys(a);
+            if (!keys.length)
+                return { name, detail: '' };
+            try {
+                return { name, detail: oneLine(JSON.stringify(a)) };
+            }
+            catch {
+                return { name, detail: '' };
+            }
+        }
+    }
+}
+/**
+ * A cheap heuristic for the STATUS ICON next to a tool result: a result that
+ * clearly reports a failure gets ✖, a normal one ✔. The agent loop returns a
+ * failed tool as a string beginning with "Error"/"Missing required argument"
+ * (see src/tools.ts), so matching those prefixes is reliable enough — a false
+ * "✔" on an unusual error body is harmless (the text is still shown).
+ */
+export function looksLikeToolError(result) {
+    const head = String(result ?? '')
+        .trim()
+        .slice(0, 60)
+        .toLowerCase();
+    if (!head)
+        return false;
+    return (head.startsWith('error') ||
+        head.startsWith('missing required argument') ||
+        head.startsWith('failed') ||
+        head.includes('command failed') ||
+        head.includes('exit code'));
+}