zames_pro 2.82.48 → 2.82.50

package/dist/provider-command.js

@@ -0,0 +1,29 @@
+import { providerHasModelPicker, providerLabel, isProviderId, PROVIDER_IDS, } from './providers.js';
+import { translate } from './i18n.js';
+/** Parse the text after `/provider` into an intent. `current` is the ACTIVE id. */
+export function parseProviderIntent(arg, current) {
+    const a = String(arg ?? '')
+        .trim()
+        .toLowerCase();
+    if (!a || a === 'status')
+        return { kind: 'status' };
+    if (a === 'login')
+        return { kind: 'login' };
+    if (isProviderId(a))
+        return { kind: 'switch', provider: a, same: a === current };
+    return { kind: 'usage' };
+}
+/** The usage line for an unknown `/provider` argument. */
+export function providerUsageMessage(t = translate('en')) {
+    return t('provider.usage', { providers: PROVIDER_IDS.join('|') });
+}
+/**
+ * Why a provider with no model picker cannot be selected via `/model`.
+ * (Kept here as well as in model-command so the two commands share the
+ * capability check instead of each hardcoding a provider id.)
+ */
+export function providerWithoutPickerMessage(provider, t = translate('en')) {
+    if (providerHasModelPicker(provider))
+        return null;
+    return t('model.unsupported', { provider: providerLabel(provider) });
+}

package/dist/provider-handoff.js

@@ -133,10 +133,27 @@ function sameDir(a, b) {
     };
     return real(x) === real(y);
 }
-/** Remove the handoff once it has been posted (or is stale). Best-effort. */
+/** Remove the handoff once it has been posted (or is stale). Best-effort.
+ *
+ *  The GLOBAL file and every per-workdir SIDE file are removed. Clearing only
+ *  the global one left a displaced record readable through its side file, so
+ *  an already-consumed summary was posted again on a later switch in that
+ *  project ("the summary came back from the dead"). Side files are small and
+ *  their whole purpose is a pending handoff, so removing all of them is safe. */
 export function clearProviderHandoff() {
     try {
         fs.unlinkSync(HANDOFF_FILE);
     }
     catch { }
+    try {
+        for (const f of fs.readdirSync(ZAMES_HOME)) {
+            if (!f.startsWith('provider-handoff-') || !f.endsWith('.json'))
+                continue;
+            try {
+                fs.unlinkSync(path.join(ZAMES_HOME, f));
+            }
+            catch { }
+        }
+    }
+    catch { }
 }

package/dist/queue-command.js

@@ -0,0 +1,15 @@
+import { formatQueueList } from './commands.js';
+/**
+ * The full output of `/queue` (minus the `clear` SIDE EFFECT, which the caller
+ * performs on its own live queue). `sub` is the parsed subcommand or null when
+ * it was not recognized; `count` is the live queue length.
+ */
+export function renderQueueView(sub, count, queue) {
+    if (!sub)
+        return { kind: 'usage' };
+    if (sub === 'clear')
+        return { kind: 'cleared', n: count };
+    if (!count || !queue.length)
+        return { kind: 'empty' };
+    return { kind: 'list', lines: formatQueueList(queue) };
+}

package/dist/qwen-chats.js

@@ -187,12 +187,19 @@ export function parseQwenHistory(json) {
             arr = asArr(d.messages);
         else if (d.chat && typeof d.chat === 'object') {
             const chat = d.chat;
-            const hist = chat.history && typeof chat.history === 'object'
-                ? chat.history
-                : null;
-            if (hist && hist.messages)
-                arr = asArr(hist.messages);
-            else if (chat.messages)
+            // `history` may itself be the message LIST (an array), not only an
+            // object with a `messages` field: the array form was read as
+            // `history.messages` -> undefined and the whole restored dialogue came
+            // back EMPTY even though the payload carried it.
+            const hist = chat.history;
+            if (Array.isArray(hist))
+                arr = hist;
+            else if (hist && typeof hist === 'object') {
+                const h = hist;
+                if (h.messages)
+                    arr = asArr(h.messages);
+            }
+            if (!arr && chat.messages)
                 arr = asArr(chat.messages);
         }
     }

package/dist/qwen-net-capture.js

@@ -97,6 +97,12 @@ function pickAnswer(node) {
     if (typeof node !== 'object')
         return '';
     const obj = node;
+    // A plain-JSON reply can carry the SAME phase marker as an SSE delta
+    // (`thinking_summary`). The reasoning guard used to live only in the
+    // choices[] branch, so a top-level `{phase:"thinking_summary",content}`
+    // (or the same object one envelope deeper) was returned as the ANSWER.
+    if (isThinkingPhase(obj))
+        return '';
     if (Array.isArray(obj.choices)) {
         let out = '';
         for (const ch of obj.choices) {
@@ -220,13 +226,14 @@ export function isRateLimitText(body) {
     const b = String(body || '');
     if (!b)
         return false;
-    // `quota_limit` is a SEPARATE code Qwen returns in the SSE error field
-    // ("The service is currently experiencing high demand. Please try again
-    // later.") — a TRANSIENT capacity limit, so it belongs with the rate-limit
-    // family (back off and retry), not with the guest DAILY limit.
-    if (/quota_limit/i.test(b))
+    const errNotice = /event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b);
+    // The `quota_limit` CODE only means something in an ERROR payload: a normal
+    // ANSWER may MENTION `quota_limit` (the operator asked how to handle that
+    // API error), and this check used to run BEFORE the answer-content guard, so
+    // such an answer made ask() back off and re-send a good turn.
+    if (/quota_limit/i.test(b) && (errNotice || !hasAnswerContent(b)))
         return true;
-    if (/event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b)) {
+    if (errNotice) {
         return /too many requests|rate limit|too frequent|please try again later|high demand|слишком часто/i.test(b);
     }
     // No structured error marker: only treat the body as a notice when it has

package/dist/resume-command.js

@@ -0,0 +1,38 @@
+import { translate } from './i18n.js';
+// Pure half of the session commands (/sessions, /resume-id). The resume itself
+// drives a browser; deciding WHICH session may be opened — the filter, the id
+// normalization, a foreign-provider refusal — is pure and lives here.
+/** Parse the text after `/resume-id` into a chat id, or null when empty. */
+export function parseResumeId(arg) {
+    const id = String(arg ?? '').trim();
+    return id ? id : null;
+}
+/** Keep the sessions matching a `/sessions <query>` filter (title or workdir). */
+export function filterSessions(sessions, filter) {
+    const q = String(filter ?? '')
+        .trim()
+        .toLowerCase();
+    if (!q)
+        return sessions.slice();
+    return sessions.filter((s) => (s.title || '').toLowerCase().includes(q) ||
+        (s.workdir || '').toLowerCase().includes(q));
+}
+/**
+ * A chat id only exists on the backend that created it, so opening a session
+ * saved by ANOTHER provider would fail inside the browser with a confusing
+ * error. Old files carry no `provider` field and belong to DeepSeek (the only
+ * backend that existed then).
+ *
+ * Returns a user-facing refusal, or null when the session may be opened.
+ */
+export function resumeProviderRefusal(session, activeProvider, t = translate('en')) {
+    if (!session)
+        return null;
+    const owner = session.provider || 'deepseek';
+    if (owner === activeProvider)
+        return null;
+    return t('sessions.provider_mismatch', {
+        owner,
+        active: activeProvider,
+    });
+}

package/dist/send-telemetry.js

@@ -43,7 +43,13 @@ export function parseSendEvents(raw) {
 export function summarizeSends(events, now = Date.now()) {
     const within = (ms) => events.filter((e) => {
         const t = Date.parse(e.at);
-        return Number.isFinite(t) && now - t <= ms;
+        // The event must be in the PAST: a future stamp (clock skew on the
+        // machine that wrote the log, a hand-edited line) satisfies
+        // `now - t <= ms` for EVERY window and inflated all three counters.
+        if (!Number.isFinite(t))
+            return false;
+        const age = now - t;
+        return age >= 0 && age <= ms;
     }).length;
     // `blockMs` may arrive as a NUMBER (the writer) or a string (an older
     // build, a hand-edited file): a numeric string is accepted so the average
@@ -62,9 +68,15 @@ export function summarizeSends(events, now = Date.now()) {
         avgBlockMs,
     };
 }
-/** `~/.zames/logs/sends-<provider>.jsonl`. */
+/** `~/.zames/logs/sends-<provider>.jsonl`. The provider id comes from the
+ *  CONFIG (a hand-edited file, `/provider`), so it must not be able to escape
+ *  the log directory: a separator or `..` used to build a path OUTSIDE
+ *  `~/.zames/logs` (a subdirectory at best, another file at worst — and the
+ *  rotation DELETES files it finds there). Everything outside a plain file-name
+ *  alphabet is replaced with `_`. */
 export function sendLogPath(logsDir, provider) {
-    return path.join(logsDir, 'sends-' + provider + '.jsonl');
+    const safe = String(provider || 'unknown').replace(/[^A-Za-z0-9._-]/g, '_');
+    return path.join(logsDir, 'sends-' + safe + '.jsonl');
 }
 /** Keep at most `keep` sends-*.jsonl files (rotate the oldest away). */
 export function rotateSendLogs(logsDir, keep = 5) {

package/dist/send-throttle.js

@@ -87,7 +87,9 @@ export function applySendEvent(state, event, cfg, now = Date.now()) {
         next.blockedAt = state.blocked ? state.blockedAt || stamp : stamp;
         next.okStreak = 0;
         next.forcedWaitMs =
-            typeof event.retryAfterMs === 'number' && event.retryAfterMs > 0
+            typeof event.retryAfterMs === 'number' &&
+                Number.isFinite(event.retryAfterMs) &&
+                event.retryAfterMs > 0
                 ? event.retryAfterMs
                 : cfg.rateLimitWaitMs;
         next.forcedWaitAt = now;

package/dist/status-command.js

@@ -0,0 +1,68 @@
+import { translate } from './i18n.js';
+/** Render `/status` as an array of lines (already localized). */
+export function formatStatus(s, t = translate('en')) {
+    const yes = t('common.yes');
+    const no = t('common.no');
+    const none = t('common.none');
+    const onoff = (b) => (b ? t('common.on') : t('common.off'));
+    const lines = [];
+    lines.push(t('status.workdir', { v: s.workdir }));
+    lines.push(t('status.review_mode', { v: s.reviewMode || t('status.review_none') }));
+    if (s.reviewMode && s.origDir) {
+        lines.push(t('status.orig_dir', { v: s.origDir }));
+    }
+    lines.push(t('status.chat', { v: s.chatId || none }));
+    lines.push(t('status.fresh_next', { v: s.freshNext ? yes : no }));
+    lines.push(t('status.prompt_next', { v: s.promptNext ? yes : no }));
+    lines.push(t('status.last_chat', { v: s.lastChat || none }));
+    lines.push(t('status.sessions', { v: s.sessionsDir }));
+    lines.push(t('status.dev', { v: s.devMode ? t('common.on') : t('common.off') }));
+    lines.push(t('status.max_iter', { v: s.maxIterations }));
+    lines.push(t('status.headless', { v: s.headless ? yes : no }));
+    lines.push(t('status.debug', { v: s.debug ? yes : no }));
+    lines.push(t('status.toggles', {
+        think: s.deepThinking ? yes : no,
+        search: s.webSearch ? yes : no,
+    }));
+    lines.push(t('status.undo', { v: onoff(s.undo) }));
+    lines.push(t('status.checkpoint', { v: onoff(s.checkpoint) }));
+    lines.push(t('status.transcript', { v: s.transcriptFile || t('common.off') }));
+    lines.push(t('status.goal', { v: s.goal || none }));
+    lines.push(t('status.locale', { v: s.localeName }));
+    lines.push(t('status.mcp', { v: s.mcpToolCount === null ? none : s.mcpToolCount }));
+    lines.push(t('status.tokens', {
+        v: s.tokenUsage === null ? t('common.unknown') : s.tokenUsage,
+    }));
+    return lines;
+}
+/**
+ * The `/doctor` rows that depend on a LIVE PROBE rather than on the config:
+ * git availability + branch, clipboard, MCP, the auth marker and the UI health
+ * result. `renderDoctor` (commands.ts) renders the full table from these.
+ */
+export function doctorProbeSummary(p) {
+    const rows = [];
+    rows.push({
+        status: p.gitOk ? 'ok' : 'warn',
+        label: p.gitOk ? 'git: ' + (p.gitBranch || 'detached') : 'git: absent',
+    });
+    rows.push({
+        status: p.authSaved ? 'ok' : 'warn',
+        label: p.authSaved ? 'auth: saved' : 'auth: not saved',
+    });
+    rows.push({
+        status: p.mcpTools > 0 ? 'ok' : 'warn',
+        label: 'mcp: ' +
+            String(p.mcpServers) +
+            ' servers / ' +
+            String(p.mcpTools) +
+            ' tools',
+    });
+    if (p.uiMissingCritical && p.uiMissingCritical.length) {
+        rows.push({
+            status: 'warn',
+            label: 'ui: missing ' + p.uiMissingCritical.join(', '),
+        });
+    }
+    return rows;
+}

package/dist/tool-summary.js

@@ -101,5 +101,12 @@ export function looksLikeToolError(result) {
         head.startsWith('subagent failed') ||
         head.startsWith('subagent error') ||
         head.includes('process killed') ||
-        head.startsWith('(aborted by the operator)'));
+        head.startsWith('(aborted by the operator)') ||
+        // A SANDBOX refusal: `safePath` throws
+        // `Access outside the working directory is forbidden: …` and the shell
+        // guard throws `Sandbox: …` (eval+cd, an unresolvable cd target, chroot).
+        // Both mean the call did NOTHING, yet neither prefix matched and the
+        // operator saw a green check next to a refused call.
+        head.includes('outside the working directory is forbidden') ||
+        head.includes('sandbox:'));
 }

package/dist/tools.js

@@ -417,7 +417,10 @@ export function filterToolsForReadOnly(tools) {
 export function filterToolsByAllowList(tools, allowed) {
     if (!allowed || !allowed.length)
         return tools;
-    const allow = new Set(allowed.map((n) => n.toLowerCase()));
+    // `allowed-tools:` is human-written: an entry may carry surrounding spaces
+    // (a quoted value, a trailing comma). Lower-casing alone left `read `, which
+    // matched nothing and silently reduced the skill to `respond` only.
+    const allow = new Set(allowed.map((n) => String(n).trim().toLowerCase()).filter(Boolean));
     allow.add('respond');
     return tools.filter((t) => allow.has(t.name.toLowerCase()));
 }

package/dist/tui/log-window.js

@@ -20,6 +20,26 @@ function visWidth(s) {
                     i++;
                 i++;
             }
+            else if (s[i] === ']') {
+                // OSC sequence: `ESC ] ... (BEL | ESC \)`. OSC-8 hyperlinks
+                // (produced by renderMarkdown when the terminal supports them) wrap
+                // the LABEL in such a sequence, and the OLD parser did not skip it:
+                // every URL character counted as a visible column, so the viewport
+                // believed a short link line filled many rows and the log jumped.
+                i++;
+                while (i < s.length) {
+                    const c = s.charCodeAt(i);
+                    if (c === 7) {
+                        i++;
+                        break;
+                    }
+                    if (c === 27 && s[i + 1] === String.fromCharCode(92)) {
+                        i += 2;
+                        break;
+                    }
+                    i++;
+                }
+            }
             continue;
         }
         const cp = s.codePointAt(i);
@@ -73,21 +93,38 @@ export function windowByRows(entries, height, scroll, cols) {
     let skip = Math.max(0, Math.floor(scroll));
     const picked = [];
     let used = 0;
+    // The pane above the panel is flexGrow:1 and overflow="hidden" with
+    // justifyContent="flex-end", so only the TAIL of a too-tall entry stays
+    // visible. `used` must therefore count the VISIBLE rows of the entry being
+    // kept, not its full height: counting the full height while scrolling
+    // INSIDE a tall entry exceeded the reserved height and pushed the status /
+    // input rows off a short terminal (the caret then drifted under the box).
     for (let i = entries.length - 1; i >= 0; i--) {
         const r = entryRows(entries[i], cols);
+        let visibleRows = r;
         if (skip > 0) {
             if (skip >= r) {
                 skip -= r;
                 continue;
             }
-            // Partially scrolled into this entry: keep the hidden part accounted.
+            // Partially scrolled into this entry: the rows above the fold are
+            // hidden and must not be counted against the viewport.
+            visibleRows = r - skip;
             skip = 0;
         }
-        if (used + r > cap && picked.length > 0)
+        // The pane is flexGrow:1 + overflow="hidden" + flex-end, so a tall entry
+        // is CLIPPED to its tail and never grows the window. A clipped entry is
+        // therefore always kept — dropping it blanked the pane while the operator
+        // scrolled inside a long answer (the old code required a free row for it).
+        const clipped = r > cap || visibleRows < r;
+        if (!clipped && used + visibleRows > cap)
             break;
         picked.push(entries[i]);
-        used += r;
-        if (used >= cap)
+        used += visibleRows;
+        // Only an EXACT fill stops the walk. A clipped entry already fills the
+        // viewport visually but leaves room in the budget for the shorter entries
+        // above it, which used to be dropped right after a tall one.
+        if (!clipped && used >= cap)
             break;
     }
     picked.reverse();

package/dist/undo.js

@@ -17,7 +17,17 @@ export class UndoStore {
     }
     async _readIndex() {
         try {
-            return JSON.parse(await fs.readFile(INDEX, 'utf-8'));
+            const data = JSON.parse(await fs.readFile(INDEX, 'utf-8'));
+            // The index is a JSON FILE: a crash, a hand edit or an old format can
+            // leave VALID JSON that is not an array (`{}`, `null`, `"x"`, `42`),
+            // or an array with junk entries. Returning it as-is made /undo throw
+            // `history.pop is not a function` and /undo-list throw
+            // `history.slice is not a function` out of the command dispatcher.
+            if (!Array.isArray(data))
+                return [];
+            return data.filter((r) => !!r &&
+                typeof r === 'object' &&
+                typeof r.originalPath === 'string');
         }
         catch {
             return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.82.48",
+  "version": "2.82.50",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {