zames_pro 2.82.48 → 2.82.50

package/CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.82.50] - 2026-10-23
+
+### Fixed
+
+- **i18n:** a prototype member is not a translation
+- **path-token:** split semicolon-separated @file lists
+- **tui:** keep a tall log entry inside the viewport when scrolling
+- **resume:** refuse a session owned by another provider
+- **tui:** skip OSC sequences when measuring log rows
+- **layout:** wrapToWidth keeps every line within the width
+- **tools:** trim allowed-tools entries before matching
+- **config:** getByPath must not walk the prototype chain
+- **context:** strip a BOM before parsing the frontmatter
+- **telemetry:** a provider id must not escape the log directory
+- **throttle:** a non-finite retryAfterMs must not block forever
+- **auth:** do not migrate a legacy GLM marker to deepseek
+- **qwen:** accept a bare array under chat.history
+- **qwen:** a quota_limit mention inside an answer is not a rate limit
+- **glm:** a quota phrase inside an answer is not a quota error
+- **glm:** order the restored dialogue by an ISO timestamp too
+- **attach:** a throwing preview lookup must not abort the attach
+- **handoff:** clear the side handoff files too
+- **loop:** resolve a padded or upper-cased tool name
+- **mcp:** honour a profile flag given inside the command
+- **config:** re-derive the ask deadline when the answer timeout changes live
+- **diff:** compare lines with an LCS instead of by position
+- **goal:** a verdict must not match the head of a word
+- **telemetry:** ignore a send event dated in the future
+- **tui:** show a sandbox refusal as a failed tool call
+- **config:** the list does not mask a whitespace-only password
+- **attach:** never treat a URL as a local file path
+- **chats:** reject a negative accumulated_token_usage on restore
+- **qwen:** never return a thinking-phase object as the answer
+- **glm:** reject a negative token usage
+- **undo:** tolerate a corrupt undo index
+- **permissions:** match a command rule in nested MCP args
+- **status:** fall back to the default context window on an invalid limit
+- **input:** count blank lines at the end of a paste
+
+## [2.82.49] - 2026-10-22
+
+### Fixed
+
+- **goal:** /goal on no longer overwrites the goal text
+
 ## [2.82.48] - 2026-10-22
 
 ### Fixed

package/dist/agent-loop.js

@@ -958,7 +958,17 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     }
                     continue;
                 }
-                const tool = tools.find((t) => t.name === call.tool);
+                // Resolve the tool name TOLERANTLY: the model pads it with spaces or
+                // a newline (`"tool": " Bash "`) and sometimes changes its case
+                // (`bash`). An exact match reported `Unknown tool: Bash ` and the model
+                // simply repeated the same call, burning the retry budget. The first
+                // exact match still wins, so a name that really is distinct is not
+                // merged.
+                const wantName = String(call.tool ?? '')
+                    .trim()
+                    .toLowerCase();
+                const tool = tools.find((t) => t.name === call.tool) ??
+                    tools.find((t) => t.name.trim().toLowerCase() === wantName);
                 if (!tool) {
                     const err = `Unknown tool: ${call.tool}`;
                     safeToolResult(err);

package/dist/attach-flow.js

@@ -36,9 +36,13 @@ export async function awaitUploadPreview(page, names, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         for (const name of clean) {
-            const n = await page
-                .getByText(name, { exact: false })
-                .count()
+            // The lookup itself can THROW synchronously (Playwright: "Execution
+            // context was destroyed" while the page navigates). `.catch` handles a
+            // rejected promise, not a synchronous throw — without the try/catch the
+            // error escaped into `_attachFiles` and the whole attach failed. A
+            // lookup error means "not visible yet", exactly like a failed count.
+            const n = await Promise.resolve()
+                .then(() => page.getByText(name, { exact: false }).count())
                 .catch(() => 0);
             if (n > 0)
                 return;

package/dist/attach-refs.js

@@ -27,6 +27,14 @@ export async function resolveAttachPath(workdir, raw) {
         s = s.slice(1, -1);
     }
     s = s.replace(/\\ /g, ' ');
+    // A URL is never a local file. `isImageName` alone would still accept
+    // `https://example.com/a.png` (it only looks at the extension), and the
+    // RELATIVE candidate `path.resolve(workdir, 'https://…')` then becomes
+    // `https:/…` — a project that happens to have such a directory silently
+    // attached the URL as a file. A URL preceded by prose words is covered too
+    // (the same rule as looksLikeFilePath).
+    if (/(?:^|\s)[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(s))
+        return null;
     if (!looksLikeFilePath(s) && !isImageName(s))
         return null;
     const candidates = path.isAbsolute(s)

package/dist/attachments.js

@@ -186,6 +186,15 @@ export function looksLikeFilePath(text) {
         return false;
     if (/[\r\n]/.test(s))
         return false;
+    // A URL is not a file path. It contains `/` and ends in a short extension,
+    // so it used to pass, and resolveAttachPath then resolved it RELATIVELY
+    // (`https://…` -> `https:/…`): a project that happened to contain such a
+    // directory silently attached the URL as a local file instead of keeping
+    // the text. Any `scheme://` head is rejected here — INCLUDING one that sits
+    // after prose words (`see https://x/a.png`), since the whole trimmed text is
+    // handed to this check.
+    if (/(?:^|\s)[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(s))
+        return false;
     // A bare file name with an image/known extension.
     if (looksLikeFileName(s))
         return true;

package/dist/browser-chats.js

@@ -27,7 +27,14 @@ export function parseHistoryMessages(messages) {
     const list = [];
     let usage = null;
     for (const raw of messages) {
-        if (raw && typeof raw.accumulated_token_usage === 'number') {
+        // A token counter is a FINITE NON-NEGATIVE number. A negative value is a
+        // nonsense payload; it used to become browser._lastTokenUsage as-is, so
+        // the context badge vanished (tokenStatusLevel rejects a negative count)
+        // and the auto-compact percentage went negative and never fired.
+        if (raw &&
+            typeof raw.accumulated_token_usage === 'number' &&
+            Number.isFinite(raw.accumulated_token_usage) &&
+            raw.accumulated_token_usage >= 0) {
             usage = raw.accumulated_token_usage;
         }
         // Roles are matched case-insensitively, and a turn that is neither the

package/dist/browser-pure.js

@@ -245,8 +245,14 @@ export function mergeAuthMarker(raw, provider, at) {
                 providers[k] = v || {};
         }
         else if (j && typeof j === 'object') {
-            if (j.provider === 'qwen')
-                providers.qwen = { at: j.at };
+            // A legacy record carries ONE provider name. Only Qwen and GLM ever wrote
+            // one (`{provider:'qwen'|'glm', at}`); a BARE `{at}` was DeepSeek. Treating
+            // every non-qwen name as DeepSeek filed a legacy GLM session under
+            // `deepseek`, so /doctor reported a DeepSeek session and the GLM one
+            // vanished.
+            const p = typeof j.provider === 'string' ? j.provider : '';
+            if (p === 'qwen' || p === 'glm')
+                providers[p] = { at: j.at };
             else if (typeof j.at === 'string')
                 providers.deepseek = { at: j.at };
         }

package/dist/commands.js

@@ -708,6 +708,11 @@ export function parseGoalCommand(text) {
         return { sub: 'show' };
     if (rest.toLowerCase() === 'clear' || rest.toLowerCase() === 'off')
         return { sub: 'clear' };
+    // `/goal on` is the natural way to RE-ENABLE a goal after `/goal clear`;
+    // treating it as new goal text replaced the goal with the literal word
+    // `on`, which no work can satisfy. With no goal set it is a no-op.
+    if (rest.toLowerCase() === 'on')
+        return { sub: 'show' };
     return { sub: 'set', goal: rest };
 }
 // Replace [image#N] / [file#N] markers in a task with the REAL file path, so

package/dist/config-commands.js

@@ -14,7 +14,10 @@ export function configListValue(field, value, t) {
         return t('cfg.menu.default');
     if (typeof value === 'boolean')
         return value ? t('common.on') : t('common.off');
-    if (/password/i.test(field.path) && String(value).length > 0)
+    // Mask a real secret, but NOT a whitespace-only one — the same rule as
+    // configGetValue(): a blank password cannot log in, and masking it makes
+    // the list claim a password is configured while auto-login silently fails.
+    if (/password/i.test(field.path) && String(value).trim().length > 0)
         return '********';
     return JSON.stringify(value);
 }

package/dist/config-live.js

@@ -31,6 +31,16 @@ export function applyBrowserLiveConfig(path, value, browser) {
     if (!field || !(field in browser))
         return false;
     browser[field] = value;
+    // `answerTimeoutMs` is DERIVED into the watchdog (`askDeadlineMs` = the
+    // answer timeout + 60s) by the Qwen/GLM constructors. Pushing only the field
+    // left the deadline at its old value, so a LARGER timeout made the agent
+    // give up before the browser's own timeout ever fired. Re-derive it the same
+    // way the constructor does.
+    if (field === 'answerTimeoutMs' && 'askDeadlineMs' in browser) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            browser.askDeadlineMs = value + 60_000;
+        }
+    }
     return true;
 }
 /** Push undo.* / checkpoint.* changes onto the live stores. The stores copy

package/dist/config.js

@@ -601,11 +601,23 @@ export function getConfigField(path) {
 }
 export function getByPath(obj, path) {
     const parts = path.split('.');
+    // Same guard as setByPath: a dotted path must never reach the PROTOTYPE
+    // chain. `__proto__` used to return Object.prototype (an object), and
+    // `constructor` / `toString` the corresponding FUNCTION — the /config list
+    // then rendered `{}` for a field whose path did not exist instead of the
+    // default marker. Reading those keys is never meaningful for a config path.
+    // `toString`, `valueOf`, `hasOwnProperty`, ... are inherited METHODS, not
+    // config values: reading them through a dotted path returned a FUNCTION.
+    // Only an OWN property counts.
+    if (parts.some((p) => UNSAFE_PATH_KEYS.has(p)))
+        return undefined;
     let cur = obj;
     for (const p of parts) {
         if (cur === null || cur === undefined || typeof cur !== 'object') {
             return undefined;
         }
+        if (!Object.prototype.hasOwnProperty.call(cur, p))
+            return undefined;
         cur = cur[p];
     }
     return cur;

package/dist/context-command.js

@@ -0,0 +1,6 @@
+import { formatContextSources } from './commands.js';
+import { translate } from './i18n.js';
+/** Render the `/context` report for already-loaded sources. */
+export function renderContextReport(src, opts = {}, t = translate('en')) {
+    return formatContextSources(src.agents || [], src.memory || [], src.skills || [], src.commands || [], opts, t);
+}

package/dist/context.js

@@ -245,7 +245,14 @@ const PROJECT_SKILL_DIRS = [
     'skills',
 ];
 function parseFrontmatter(raw) {
-    const norm = raw.replace(CRLF_RE, NL);
+    // A leading BOM must be dropped BEFORE the `---` check: Windows editors and
+    // generators write one, and without this the frontmatter was not recognised
+    // at all (description / argument-hint / arguments silently lost).
+    // `skillBody` already strips it; the two must agree.
+    const bom = String.fromCharCode(0xfeff);
+    const norm = String(raw ?? '')
+        .replace(new RegExp('^' + bom), '')
+        .replace(CRLF_RE, NL);
     if (!norm.startsWith('---'))
         return {};
     const end = norm.indexOf(NL + '---', 3);

package/dist/diff.js

@@ -2,22 +2,65 @@ import { theme } from './theme.js';
 export function unifiedDiff(a, b, { label = '' } = {}) {
     const la = a.split(String.fromCharCode(10));
     const lb = b.split(String.fromCharCode(10));
-    const n = Math.max(la.length, lb.length);
     const out = [];
     if (label)
         out.push('... ' + label);
-    for (let i = 0; i < n; i++) {
-        const x = la[i];
-        const y = lb[i];
-        if (x === y)
+    // A LINE diff, not a positional compare: an insertion at the top of a
+    // file shifts every following line, and comparing line i with line i
+    // reported the WHOLE file as removed AND added (a 20-line file with one
+    // new first line produced 41 diff lines). The undo/`/diff` preview became
+    // unreadable and the model was told everything changed. A longest-common-
+    // subsequence walk emits only the lines that really differ.
+    for (const op of diffOps(la, lb)) {
+        if (op.kind === 'same')
             continue;
-        if (x !== undefined)
-            out.push('-' + x);
-        if (y !== undefined)
-            out.push('+' + y);
+        out.push((op.kind === 'del' ? '-' : '+') + op.line);
     }
     return out.join(String.fromCharCode(10));
 }
+/**
+ * Longest-common-subsequence line diff (Hunt–Szymanski style table, O(n*m)
+ * memory). Files here are a handful of lines (a single edit preview), so the
+ * simple dynamic-programming table is fine and keeps the module dependency-
+ * free. A change pair is emitted as `-old` then `+new`, like a real diff.
+ */
+function diffOps(a, b) {
+    const n = a.length;
+    const m = b.length;
+    // lcs[i][j] = length of the LCS of a[i..] and b[j..].
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] =
+                a[i] === b[j]
+                    ? lcs[i + 1][j + 1] + 1
+                    : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            ops.push({ kind: 'same', line: a[i] });
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            ops.push({ kind: 'del', line: a[i] });
+            i++;
+        }
+        else {
+            ops.push({ kind: 'add', line: b[j] });
+            j++;
+        }
+    }
+    while (i < n)
+        ops.push({ kind: 'del', line: a[i++] });
+    while (j < m)
+        ops.push({ kind: 'add', line: b[j++] });
+    return ops;
+}
 export function colorDiff(diffText) {
     return diffText
         .split(String.fromCharCode(10))

package/dist/glm-chats.js

@@ -157,9 +157,26 @@ export function parseGlmHistory(json) {
             : null;
     if (!arr)
         return [];
+    // The map is UNORDERED and `timestamp` restores the dialogue order. The
+    // value is a NUMBER or a numeric string in the builds seen so far, but an
+    // ISO stamp (`2026-10-23T10:00:00Z`) makes `Number(...)` NaN, and a NaN
+    // comparator keeps the INSERTION order — a scrambled dialogue. Fall back to
+    // Date.parse for a non-numeric string.
+    const stampOf = (m) => {
+        const raw = m.timestamp;
+        const n = Number(raw);
+        if (Number.isFinite(n) && n !== 0)
+            return n;
+        if (typeof raw === 'string') {
+            const t = Date.parse(raw);
+            if (Number.isFinite(t))
+                return t;
+        }
+        return 0;
+    };
     const sorted = arr
         .filter((x) => !!x && typeof x === 'object')
-        .sort((a, b) => (Number(a.timestamp) || 0) - (Number(b.timestamp) || 0));
+        .sort((a, b) => stampOf(a) - stampOf(b));
     const out = [];
     for (const m of sorted) {
         // The role comes from `role` (confirmed by the live fixture). Only the

package/dist/glm-net-capture.js

@@ -172,6 +172,10 @@ export function extractAnswer(body) {
         return sse;
     return extractFromJson(body);
 }
+/** A usable token count: a FINITE NON-NEGATIVE number. */
+function isUsageCount(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0;
+}
 /**
  * The CONTEXT size (tokens) from `usage.prompt_tokens` - the prompt size for
  * the turn, the same idea as DeepSeek's accumulated_token_usage. Falls back to
@@ -186,9 +190,14 @@ export function extractTokenUsage(body) {
         if (!usage || typeof usage !== 'object')
             continue;
         const u = usage;
-        if (typeof u.prompt_tokens === 'number' && Number.isFinite(u.prompt_tokens))
+        // A token count is a FINITE NON-NEGATIVE number. A negative payload (a
+        // nonsense reply, or a wrapped `int` in a proxy build) used to become
+        // `browser._lastTokenUsage` as-is: the context badge disappeared
+        // (tokenStatusLevel rejects it) while the auto-compact percentage went
+        // negative and never fired. Treat it as "no usage", like a non-number.
+        if (isUsageCount(u.prompt_tokens))
             lastPrompt = u.prompt_tokens;
-        if (typeof u.total_tokens === 'number' && Number.isFinite(u.total_tokens))
+        if (isUsageCount(u.total_tokens))
             lastTotal = u.total_tokens;
     }
     if (lastPrompt !== null)
@@ -205,9 +214,9 @@ export function extractTokenUsage(body) {
             : null;
         const usage = ((envelope ? envelope.usage : undefined) ?? obj?.usage);
         if (usage) {
-            if (typeof usage.prompt_tokens === 'number')
+            if (isUsageCount(usage.prompt_tokens))
                 return usage.prompt_tokens;
-            if (typeof usage.total_tokens === 'number')
+            if (isUsageCount(usage.total_tokens))
                 return usage.total_tokens;
         }
     }
@@ -279,7 +288,16 @@ const ERROR_PAYLOAD_RE = /"type"\s*:\s*"error"|"error"\s*:|\{\s*"code"\s*:/i;
  * message instead of retrying for the whole budget.
  */
 export function isQuotaExhaustedText(body) {
-    return /insufficient_quota|quota (?:exceeded|exhausted)|exceeded your current quota/i.test(String(body || ''));
+    const b = String(body || '');
+    if (!b)
+        return false;
+    // Same guard as every other z.ai classifier: a normal ANSWER may legitimately
+    // discuss `insufficient_quota` / "exceeded your current quota" (the operator
+    // asked how to handle that API error). Without this the answer was taken for
+    // a refusal and a good turn was abandoned with `glm.quota_exhausted`.
+    if (!ERROR_PAYLOAD_RE.test(b) && hasAnswerContent(b))
+        return false;
+    return /insufficient_quota|quota (?:exceeded|exhausted)|exceeded your current quota/i.test(b);
 }
 export function isRateLimitText(body) {
     const b = String(body || '');

package/dist/goal.js

@@ -96,7 +96,12 @@ export function parseGoalVerdict(text) {
     // separator is checked on the character FOLLOWING the matched value (a
     // lookahead INSIDE the value pattern was useless: the value alternatives
     // always end on a word boundary of their own).
-    const label = /VERDICT\s*[*_`]*\s*:\s*[*_`]*\s*(IMPOSSIBLE|NOT[_ -]?MET|MET)/gi;
+    // A right boundary is REQUIRED: without it `VERDICT: METS` /
+    // `METADATA` parsed as MET, and MET CLEARS the goal — an unfinished task
+    // looked done. `\b` alone is not enough: in `MET-ish` the hyphen is a word
+    // boundary, so a hyphen/underscore directly after the value is rejected
+    // explicitly (a hyphen is only legal INSIDE `NOT-MET`).
+    const label = /VERDICT\s*[*_`]*\s*:\s*[*_`]*\s*(IMPOSSIBLE|NOT[_ -]?MET|MET)(?![\w-])/gi;
     let m;
     let status = null;
     while ((m = label.exec(t)) !== null) {

package/dist/i18n/self-review.js

@@ -183,4 +183,8 @@ export const selfReviewMessages = {
         ru: 'Использование: /resume-id <chat id>',
         en: 'Usage: /resume-id <chat id>',
     },
+    'sessions.provider_mismatch': {
+        ru: 'Сессия принадлежит провайдеру {owner}, а активен {active}: чат не откроется. Переключись командой /provider {owner} и повтори.',
+        en: 'This session belongs to {owner}, but {active} is active: the chat will not open. Switch with /provider {owner} and retry.',
+    },
 };

package/dist/i18n.js

@@ -55,7 +55,13 @@ export const CATALOG = {
 export function translate(locale) {
     const loc = isLocale(locale) ? locale : DEFAULT_LOCALE;
     return (key, params) => {
-        const entry = CATALOG[key];
+        // A plain-object lookup ALSO resolves Object.prototype members, so a key
+        // like 'toString' returned the inherited FUNCTION: the caller got
+        // `undefined` (no params) or a TypeError (`.replace is not a function`).
+        // Only an OWN entry is a translation.
+        const entry = Object.prototype.hasOwnProperty.call(CATALOG, key)
+            ? CATALOG[key]
+            : undefined;
         const template = entry ? entry[loc] || entry[DEFAULT_LOCALE] : key;
         if (!params)
             return template;