zames_pro 2.82.49 → 2.82.51

package/dist/path-token.js

@@ -89,7 +89,7 @@ function stripRefPunct(tok) {
         t = t.slice(0, -1);
     return t;
 }
-// Find all `@path` references in a task text (B5). Returns the unique paths in
+// Find all `@path` references in a task text. Returns the unique paths in
 // order of appearance. A reference is an '@' at a word boundary followed by a
 // token that looks like a file name/path (a known extension). Implemented
 // without regular expressions, like extractPathToken, to keep the source free
@@ -107,35 +107,62 @@ export function extractAtFileRefs(text) {
             continue;
         }
         const prev = i > 0 ? chars[i - 1] : '';
-        // A comma separates list items: `@a.ts,@b.ts` is TWO references. The
-        // comma itself is not a boundary (it is stripped as prose punctuation),
-        // so without this the second `@` never started a new scan and its file was
-        // never inlined.
-        if (prev && !isRefBoundary(prev) && prev !== ',') {
+        // The at-sign must START a reference: at the very beginning, after
+        // whitespace/a bracket/a quote, or right after a LIST SEPARATOR (a comma
+        // or a semicolon). A second at-sign WITHOUT a separator (`@a.ts@b.ts`) is
+        // an email/decorator shape and is skipped — the glued path cannot be
+        // inlined anyway.
+        if (prev && !isRefBoundary(prev) && prev !== ',' && prev !== ';') {
             i++;
             continue;
         }
         let j = i + 1;
         let tok = '';
+        // The token is rejected WHOLE when it contains an at-sign that is NOT a
+        // list separator — `@Component` / `user@host` are a decorator and an
+        // email. Trimming the prefix at that at-sign would otherwise inline a
+        // bogus path.
+        let hadInnerAt = false;
+        // A token that contains an at-sign (`@Component`, `user@host`) is a
+        // decorator / an email, NOT a file reference. The scan used to stop at
+        // that at-sign and hand the PREFIX (`Component` … no) or, worse, the part
+        // BEFORE it to the inliner. Now the whole token is rejected instead.
+        const isRef = (t) => t.length > 0 && !t.includes('@');
         while (j < n && !isRefEnd(chars[j])) {
             // A COMMA directly followed by another `@` starts the NEXT reference:
             // `@a.ts,@b.ts` is a list, and scanning to whitespace made the whole
             // `a.ts,@b.ts` one path, so neither file was inlined.
             if (chars[j] === ',' && chars[j + 1] === '@')
                 break;
+            // A SEMICOLON or a second at-sign also separates list items. Scanning
+            // to whitespace made `a.ts;@b.ts` ONE path whose extension consumed the
+            // separator, so `looksLikeToken` failed and BOTH files were dropped.
+            if ((chars[j] === ';' || chars[j] === '@') && chars[j + 1] === '@')
+                break;
+            // An at-sign followed by an ordinary char is part of the token (an
+            // email/decorator) — remember it so the token is rejected below.
+            if (chars[j] === '@')
+                hadInnerAt = true;
             tok += chars[j];
             j++;
         }
         const cleaned = stripRefPunct(tok);
-        if (cleaned && looksLikeToken(cleaned) && !seen.has(cleaned)) {
+        if (!hadInnerAt &&
+            isRef(cleaned) &&
+            looksLikeToken(cleaned) &&
+            !seen.has(cleaned)) {
             seen.add(cleaned);
             out.push(cleaned);
         }
         // The break above leaves `j` ON the comma; step past it so the next `@`
         // is seen as the start of a reference. When the scan ended on a
         // terminator instead, continue AFTER it.
-        if (chars[j] === ',' && chars[j + 1] === '@')
-            i = j + 1;
+        // The scan stopped ON a separator that split the token (`,`, `;` or a
+        // second at-sign): resume AT it so the next part is scanned as its own
+        // reference. Continuing past it dropped the second file of a list.
+        const sep = j < n ? chars[j] : '';
+        if (j > i + 1 && (sep === ',' || sep === ';' || sep === '@'))
+            i = j;
         else
             i = j > i + 1 ? j : i + 1;
     }

package/dist/permissions.js

@@ -156,14 +156,43 @@ export function decidePermission(policy, tool, args) {
     // the natural shape for execFile-style MCP tools). Accepting only strings
     // let a `command` deny be bypassed by passing the words as an array.
     const commands = [];
-    for (const k of COMMAND_KEYS) {
-        const v = a[k];
+    // Collect a value as a command string: a string is one command, an ARRAY
+    // (argv) is joined into one line so a rule can match the words in order.
+    const addCommand = (v) => {
         if (typeof v === 'string')
             commands.push(v);
         else if (Array.isArray(v)) {
-            commands.push(v.filter((x) => typeof x === 'string').join(' '));
+            const parts = v.filter((x) => typeof x === 'string');
+            if (parts.length)
+                commands.push(parts.join(' '));
         }
+    };
+    for (const k of COMMAND_KEYS) {
+        if (k in a)
+            addCommand(a[k]);
     }
+    // MCP tools (and a model that nests its payload) send the command one or
+    // more levels down — `{args: {command}}`, `{input: {params: {cmd}}}`.
+    // Checking only the TOP level let a `command` deny rule be bypassed by
+    // wrapping the same words in an object, so nested objects and arrays are
+    // scanned too (depth-bounded like the path scan).
+    const walkCommands = (v, depth) => {
+        if (depth > 4 || v === null || v === undefined)
+            return;
+        if (Array.isArray(v)) {
+            for (const x of v)
+                walkCommands(x, depth + 1);
+            return;
+        }
+        if (typeof v !== 'object')
+            return;
+        for (const [key, val] of Object.entries(v)) {
+            if (COMMAND_KEYS.includes(key))
+                addCommand(val);
+            walkCommands(val, depth + 1);
+        }
+    };
+    walkCommands(a, 0);
     const paths = collectPathCandidates(tool, args);
     for (const r of policy.rules) {
         // An UNPARSABLE regex in any field of the rule makes the rule fail

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/subagent.js

@@ -1,6 +1,6 @@
 import { loadHooks, runLifecycleHooks } from './hooks.js';
 import { markInternalChat } from './sessions.js';
-// Subagent runner (BACKLOG N36). A `Task` tool call from the model is handled
+// Subagent runner. A `Task` tool call from the model is handled
 // by the agent loop as a SEAM (like onAutoCompact): it calls back into the
 // caller, which owns the whole lifecycle. This module builds that callback.
 //
@@ -101,17 +101,10 @@ export function createSubagentRunner(opts) {
         // parent chat id) returned BEFORE anything ran, and charging those
         // attempts burned the whole budget on runs that never started.
         used++;
-        // The model is told to fill `description` (a short label for the log/UI).
-        // Without logging it every subagent turn in the transcript was anonymous,
-        // so a long run could not be attributed to a sub-task.
-        try {
-            transcript?.log('subagent_start', {
-                type: req.type,
-                description: req.description || '',
-                promptChars: String(req.prompt || '').length,
-            });
-        }
-        catch { }
+        // NOTE: `subagent_start` is NOT logged here. agent-loop already writes it
+        // for the `Task` seam (with the description and the prompt), so logging it
+        // here too put a DUPLICATE event for the same run into the transcript —
+        // /export rendered every delegation twice. The seam owns the event.
         const subTools = buildTools(req.type === 'explore');
         const taskText = subagentPersona(req.type) + '\n\n--- SUB-TASK ---\n' + req.prompt;
         // Save the parent's send hooks: the nested loop OVERWRITES them on

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

@@ -70,6 +70,15 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
         if (v === undefined || v === null) {
             throw new Error(`Missing required argument: ${name}. Add "${name}" to the tool call arguments and retry.`);
         }
+        // The contract says `path: string`/`command: string`; nothing used to
+        // enforce it, so an OBJECT became "[object Object]" and the file tools
+        // CREATED a file with that literal name (the same family as the old
+        // `undefined` file). A garbled tool call is exactly this shape.
+        if (typeof v === 'object' || typeof v === 'function') {
+            throw new Error(`Invalid required argument ${name}: expected a string, got ` +
+                JSON.stringify(v) +
+                '. Re-send the call with a plain string value.');
+        }
         const s = String(v);
         if (s === '' || s === 'undefined' || s === 'null') {
             throw new Error(`Invalid required argument ${name}: ${JSON.stringify(v)}. Provide a non-empty value for "${name}" and retry.`);
@@ -417,7 +426,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/StatusBar.js

@@ -27,7 +27,7 @@ function stateLabel(state, locale) {
  *  status). Measured with the shared `visLen` so wide chars (CJK/emoji) count
  *  as 2 and the emoji's text-presentation selector (\uFE0E) as 0 — a plain
  *  `.length` counted an emoji as 1 and a CJK badge was clipped on a narrow
- *  terminal (BACKLOG T0.7). Exported so the width arithmetic is unit-tested
+ *  terminal. Exported so the width arithmetic is unit-tested
  *  without rendering. */
 export function badgeTextWidth(state) {
     let w = 0;

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/dist/web.js

@@ -654,22 +654,32 @@ export function parseDuckDuckGoResults(body, limit) {
     // single regex made the snippet group OPTIONAL with an unbounded gap, so a
     // result without a snippet picked up the FOLLOWING result's snippet (wrong
     // text under a URL). A row scan ties every snippet to its own result.
-    const anchorRe = /<a[^>]*class="[^"]*result__(a|snippet)[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
+    // A result anchor is `<a … class="… result__a|result__snippet …" …>`. The
+    // attribute VALUES may be single-quoted (HTML allows both, and a page served
+    // through a proxy does), so each quote style is accepted rather than only
+    // `class="…"`. Rejecting them made a valid page parse to zero results and
+    // WebSearch answer "the output format may have changed".
+    const anchorRe = /<a[^>]*class=(?:"([^"]*)"|'([^']*)')[^>]*>([\s\S]*?)<\/a>/gi;
     const hrefOf = (tag) => {
-        const m = tag.match(/href="([^"]*)"/i);
-        return m ? m[1] : '';
+        const m = tag.match(/href=(?:"([^"]*)"|'([^']*)')/i);
+        return m ? (m[1] ?? m[2] ?? '') : '';
     };
     let cur = null;
     let m;
     while ((m = anchorRe.exec(body))) {
-        const kind = m[1].toLowerCase();
+        const classes = m[1] ?? m[2] ?? '';
+        const kindMatch = /result__(a|snippet)/i.exec(classes);
+        if (!kindMatch)
+            continue;
+        const kind = kindMatch[1].toLowerCase();
+        const text = m[3] || '';
         if (kind === 'a') {
             if (cur && cur.title && /^https?:\/\//i.test(cur.url)) {
                 results.push(cur);
                 if (results.length >= limit)
                     return results;
             }
-            cur = { title: htmlToText(m[2] || '').trim(), url: '', snippet: '' };
+            cur = { title: htmlToText(text).trim(), url: '', snippet: '' };
             // The href lives in the OPENING tag, which m[0] starts with.
             let href = hrefOf(m[0].slice(0, m[0].indexOf('>') + 1));
             const uddg = href.match(/[?&]uddg=([^&]+)/);
@@ -685,7 +695,7 @@ export function parseDuckDuckGoResults(body, limit) {
             continue;
         }
         if (cur && !cur.snippet)
-            cur.snippet = htmlToText(m[2] || '').trim();
+            cur.snippet = htmlToText(text).trim();
     }
     if (cur && cur.title && /^https?:\/\//i.test(cur.url))
         results.push(cur);