zames_pro 2.78.2 → 2.79.0

package/CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.79.0] - 2026-10-19
+
+### Fixed
+
+- **qwen:** match the history 'from' role case-insensitively and accept human
+- **browser-chats:** match the history role case-insensitively and drop service turns
+- **extratools:** apply multi-hunk ApplyPatch updates and honour @@ line numbers
+- **web:** drop non-http(s) links from WebSearch results
+- **web:** judge 6to4 and Teredo addresses by the embedded IPv4
+- **permissions:** match path rules against arrays and nested MCP args
+- **scheduler:** reject empty and malformed cron field tokens
+- **qwen:** read numeric and map-keyed ids in the chat list
+- **xml-toolcall:** a stray brace before inline JSON no longer eats the args
+- **xml-toolcall:** keep a </parameter> literal inside a parameter value
+- **qwen:** detect a finished status carried on the choice, not only the delta
+- **config:** reject an empty value for a number setting
+- **goal:** an echoed label set is not the evaluator verdict
+- **input:** expand each paste into its own marker occurrence
+- **compact:** a summary that mentions DSML in prose is usable
+
+## [2.78.3] - 2026-10-18
+
+### Fixed
+
+- **answer-parse:** a report narrating completed steps is not unfinished work
+- **net-capture:** a short complete answer is not a finished-without-answer turn
+- **git:** keep the empty-output sentinel out of the git context
+- **tools:** make Read offset/limit 1-based like every line-numbered tool
+- **shell:** scan a glued cd target (cd../.. escaped the sandbox)
+- **web:** drop an unclosed script/style body in htmlToText
+- **diagnostics:** recognize a coloured/timestamped clean banner
+- **permissions:** fail closed on a rule with an invalid regex
+- **transcript:** sanitize the session name in the file name
+- **backlog:** strip a CR from a note title
+- **shell:** escalate to SIGKILL when a killed job traps SIGTERM
+- **input:** Tab on an empty buffer inserted a guessed command
+
 ## [2.78.2] - 2026-10-18
 
 ### Fixed

package/dist/answer-parse.js

@@ -111,6 +111,64 @@ export function looksLikeUnfinishedWork(text) {
     if (/\b(done|finished|completed|готово|выполнено|завершено)\b/i.test(t)) {
         return false;
     }
+    // A report that NARRATES a completed step ("Tests pass. Now I will run
+    // the build.", "I have updated the README.", "Fixed the bug.") recounts
+    // work that is ALREADY done. The future-tense "now …" that follows must not
+    // turn such a report back into unfinished work: the loop re-asked the model
+    // up to 3 times on a complete answer. A bare promise ("Let me run the
+    // tests") has NO completed-step clause and is still caught below.
+    // The prefix and the verb are matched SEPARATELY (not as one combined
+    // regex): with a Cyrillic alternation glued to a `\b`-prefixed group, V8
+    // silently fails to find the match. A short English/Russian verb list is
+    // checked with plain `includes` on the lowercased text.
+    const lower = t.toLowerCase();
+    const completedWords = [
+        'passed',
+        'succeeded',
+        'failed',
+        'updated',
+        'fixed',
+        'added',
+        'removed',
+        'applied',
+        'committed',
+        'pushed',
+        'installed',
+        'verified',
+        'changed',
+        'modified',
+        'implemented',
+        'reviewed',
+        'created',
+        'built',
+        'pass.',
+        'pass,',
+        'pass ',
+        'have ',
+        'has ',
+        'проходят',
+        'прошёл',
+        'прошел',
+        'успешн',
+        'готов',
+    ];
+    const completedRu = [
+        'исправил',
+        'добавил',
+        'обновил',
+        'создал',
+        'удалил',
+        'применил',
+        'запустил',
+        'проверил',
+        'изменил',
+        'сделал',
+        'выполнил',
+    ];
+    if (completedWords.some((w) => lower.includes(w)) ||
+        completedRu.some((w) => lower.includes(w))) {
+        return false;
+    }
     // `update`/`summarize`/`explain` are REPORT verbs (`I will update you on the
     // results: …`) — they do not promise a tool call. A colon anywhere in the
     // gap also means the sentence is explaining a fact, not about to act.

package/dist/backlog.js

@@ -30,7 +30,10 @@ export function parseBacklogNote(note) {
             break;
         }
     }
-    const bodyLines = body.split(NL);
+    // A note typed on Windows (or pasted from one) carries CRLF line endings;
+    // the title would keep the trailing `\r` and the heading would get a stray
+    // carriage return.
+    const bodyLines = body.split(NL).map((l) => l.replace(/\r$/, ''));
     const title = bodyLines[0];
     const rest = bodyLines.slice(1).join(NL).trim();
     return { priority, title, note: rest || undefined };

package/dist/browser-chats.js

@@ -30,7 +30,15 @@ export function parseHistoryMessages(messages) {
         if (raw && typeof raw.accumulated_token_usage === 'number') {
             usage = raw.accumulated_token_usage;
         }
-        const role = raw && raw.role === 'ASSISTANT' ? 'assistant' : 'user';
+        // Roles are matched case-insensitively, and a turn that is neither the
+        // operator nor the assistant (SYSTEM, TOOL, a future role) is DROPPED: the
+        // old `role === 'ASSISTANT'` fallback read every other turn as the
+        // operator's, so a lowercase assistant answer was printed as the operator's
+        // text in the restored dialogue.
+        const rawRole = String((raw && raw.role) || '').toUpperCase();
+        if (rawRole !== 'ASSISTANT' && rawRole !== 'USER')
+            continue;
+        const role = rawRole === 'ASSISTANT' ? 'assistant' : 'user';
         const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
         let text = '';
         for (const fr of (raw && raw.fragments) || []) {

package/dist/commands.js

@@ -544,15 +544,26 @@ export function isUsableCompactSummary(text) {
         return false;
     if (/^\(прервано пользователем\)$/.test(t))
         return false;
+    // A tool call must be RECOGNIZED as one: a plain word `DSML` in prose (the
+    // summary describing the feature) is not noise. Requiring the tag/DSML
+    // syntax keeps the guard on real protocol output without rejecting a valid
+    // summary that merely mentions the feature (which made every retry fail and
+    // forced the local fallback).
     if (parseAssistantToolCall(t))
         return false;
-    if (/DSML/i.test(t))
+    // A REAL DSML call carries the marker punctuation (`<｜DSML｜invoke`); a
+    // summary may MENTION the feature by name in prose. Matching the bare word
+    // rejected a perfectly good summary and every retry failed the same way.
+    if (/<\s*[\uFF5C|]\s*DSML/i.test(t))
         return false;
     // A tool-call body without a recognizable head (a cut-off stream) still
     // carries "args": { ... }.
     if (/"args"\s*:\s*\{/.test(t))
         return false;
-    if (/<ds_safety>/i.test(t))
+    // A REAL safety block is the marker, not a sentence that mentions it: the
+    // closing form `</ds_safety>` is what a summary would NOT write in prose
+    // (a summary may say "no <ds_safety> marker appeared").
+    if (/<\/ds_safety\s*>/i.test(t))
         return false;
     return true;
 }

package/dist/config.js

@@ -527,6 +527,12 @@ function parseConfigValue(field, raw) {
             throw new Error('boolean');
         }
         case 'number': {
+            // `Number('')` and `Number('   ')` are 0, NOT NaN: an empty value for a
+            // field with min 0 passed validation and silently BECAME 0 (an operator
+            // clearing the edit buffer turned retries/backups OFF instead of being
+            // told the value is invalid).
+            if (raw.trim() === '')
+                throw new Error('number');
             const n = Number(raw);
             if (!Number.isFinite(n))
                 throw new Error('number');

package/dist/diagnostics.js

@@ -28,11 +28,17 @@ export function summarizeDiagnostics(raw, maxChars) {
     // old 40-char cutoff — so every edit in watch mode appended a pointless
     // diagnostics block to the tool result. Treat a ZERO-count banner as clean
     // however long it is; a non-zero count still falls through to the lines.
-    if (/^(?:found\s+)?0\s+errors?\b/im.test(text))
+    // Strip ANSI colour codes and a leading `[12:00:00]`-style timestamp before
+    // the clean checks: a watch-mode banner is usually coloured and/or
+    // prefixed, and the anchored regexes missed it — every edit then
+    // appended a pointless diagnostics block.
+    const plain = text.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+    const cleanCheck = plain.replace(/^\[[^\]]*\]\s*/, '');
+    if (/^(?:found\s+)?0\s+errors?\b/im.test(cleanCheck))
         return null;
-    if (/^no errors?\.?$/im.test(text))
+    if (/^no errors?(?: found)?\.?$/im.test(cleanCheck))
         return null;
-    if (/^0 problems?\b/im.test(text))
+    if (/^0 problems?\b/im.test(cleanCheck))
         return null;
     // Keep only error-looking lines when we can recognise them, so a long build
     // log collapses to the actual problems. Fall back to the whole output.

package/dist/extraTools.js

@@ -100,81 +100,119 @@ export function parsePatch(text) {
             continue;
         }
         if (current)
-            current.lines.push(line);
+            current.lines.push(line.replace(/\r$/, ''));
     }
     if (!ops.length)
         return { ops: [], error: 'Patch contains no file operations.' };
     return { ops };
 }
-/**
- * Apply an update hunk to existing content using context matching.
- * The hunk is a list of lines prefixed with ' ' (context), '-' (remove),
- * '+' (add). We locate the context block by exact match, then by ignoring
- * trailing whitespace, then by ignoring all whitespace (like Codex).
- */
-export function applyUpdateHunk(content, hunkLines) {
-    const hasCRLF = content.includes('\r\n');
-    const fileLines = content.split(/\r?\n/);
-    const oldLines = [];
-    const newLines = [];
+/** Split a hunk list into per-`@@` blocks, remembering each header position. */
+function splitHunks(hunkLines) {
+    const blocks = [{ oldStart: null, lines: [] }];
     for (const l of hunkLines) {
-        if (l.startsWith('@@'))
+        if (l.startsWith('@@')) {
+            const m = l.match(/^@@\s*-(\d+)/);
+            blocks.push({ oldStart: m ? Number(m[1]) : null, lines: [] });
             continue;
-        if (l.startsWith('+')) {
-            newLines.push(l.slice(1));
-        }
-        else if (l.startsWith('-')) {
-            oldLines.push(l.slice(1));
-        }
-        else if (l.startsWith(' ')) {
-            oldLines.push(l.slice(1));
-            newLines.push(l.slice(1));
-        }
-        else if (l === '') {
-            oldLines.push('');
-            newLines.push('');
         }
-        else {
-            oldLines.push(l);
-            newLines.push(l);
-        }
-    }
-    if (!oldLines.length) {
-        return {
-            ok: false,
-            error: 'Hunk has no context or removed lines to anchor on.',
-        };
+        blocks[blocks.length - 1].lines.push(l);
     }
-    const norm = (s, mode) => {
-        if (mode === 'exact')
-            return s;
-        if (mode === 'trim')
-            return s.replace(/[ \t]+$/, '');
-        return s.replace(/\s+/g, '');
-    };
+    return blocks.filter((b) => b.lines.length > 0);
+}
+const hunkNorm = (s, mode) => {
+    if (mode === 'exact')
+        return s;
+    if (mode === 'trim')
+        return s.replace(/[ \t]+$/, '');
+    return s.replace(/\s+/g, '');
+};
+/**
+ * Find where a block's old side starts in `fileLines`.
+ * `from` is the lowest index allowed (hunks must not overlap / go backwards).
+ * When the header named a line, that position is preferred: repeated context
+ * is otherwise ambiguous and the wrong occurrence gets patched.
+ */
+function locateBlock(fileLines, oldLines, oldStart, from) {
+    const maxStart = fileLines.length - oldLines.length;
+    if (maxStart < from)
+        return -1;
     for (const mode of ['exact', 'trim', 'ws']) {
-        const anchor = oldLines.map((l) => norm(l, mode));
-        for (let i = 0; i + anchor.length <= fileLines.length; i++) {
-            let match = true;
+        const anchor = oldLines.map((l) => hunkNorm(l, mode));
+        const matches = (i) => {
             for (let j = 0; j < anchor.length; j++) {
-                if (norm(fileLines[i + j], mode) !== anchor[j]) {
-                    match = false;
-                    break;
-                }
+                if (hunkNorm(fileLines[i + j], mode) !== anchor[j])
+                    return false;
             }
-            if (!match)
+            return true;
+        };
+        if (oldStart !== null) {
+            const hinted = oldStart - 1;
+            if (hinted >= from && hinted <= maxStart && matches(hinted))
+                return hinted;
+        }
+        for (let i = from; i <= maxStart; i++) {
+            if (matches(i))
+                return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Apply an update hunk to existing content using context matching.
+ * The hunk is a list of lines prefixed with ' ' (context), '-' (remove),
+ * '+' (add). Several `@@` hunks for one file are applied in order, top to
+ * bottom. A block is located by exact match, then ignoring trailing
+ * whitespace, then ignoring all whitespace (like Codex).
+ */
+export function applyUpdateHunk(content, hunkLines) {
+    const hasCRLF = content.includes('\r\n');
+    const eol = hasCRLF ? '\r\n' : NL;
+    let fileLines = content.split(/\r?\n/);
+    for (const block of splitHunks(hunkLines)) {
+        const oldLines = [];
+        const newLines = [];
+        for (const l of block.lines) {
+            // A blank hunk line is the newline BEFORE "*** End Patch", not a
+            // context line: counting it as context demanded an extra blank file
+            // line and made every realistic multi-hunk patch fail.
+            if (l === '')
                 continue;
-            const before = fileLines.slice(0, i);
-            const after = fileLines.slice(i + anchor.length);
-            const joined = [...before, ...newLines, ...after].join(hasCRLF ? '\r\n' : NL);
-            return { ok: true, content: joined };
+            if (l.startsWith('+')) {
+                newLines.push(l.slice(1));
+            }
+            else if (l.startsWith('-')) {
+                oldLines.push(l.slice(1));
+            }
+            else if (l.startsWith(' ')) {
+                oldLines.push(l.slice(1));
+                newLines.push(l.slice(1));
+            }
+            else {
+                oldLines.push(l);
+                newLines.push(l);
+            }
+        }
+        if (!oldLines.length) {
+            return {
+                ok: false,
+                error: 'Hunk has no context or removed lines to anchor on.',
+            };
         }
+        const at = locateBlock(fileLines, oldLines, block.oldStart, 0);
+        if (at === -1) {
+            return {
+                ok: false,
+                error: 'Context not found in the file (hunk did not match): ' +
+                    oldLines[0].slice(0, 60),
+            };
+        }
+        fileLines = [
+            ...fileLines.slice(0, at),
+            ...newLines,
+            ...fileLines.slice(at + oldLines.length),
+        ];
     }
-    return {
-        ok: false,
-        error: 'Context not found in the file (hunk did not match): ' +
-            oldLines[0].slice(0, 60),
-    };
+    return { ok: true, content: fileLines.join(eol) };
 }
 // ---------- factory ----------
 export function createExtraTools(workdir, { undo, todos } = {}) {

package/dist/gitTools.js

@@ -1,5 +1,9 @@
 import { execFile } from 'child_process';
 const BS = String.fromCharCode(92);
+// What runGitArgs answers for an EMPTY successful run. Callers that parse the
+// output must not mistake it for real content (a clean tree is not "one
+// modified file whose name is this string").
+export const NO_OUTPUT_SENTINEL = '(command produced no output)';
 // Run git with an argument ARRAY (no shell). ALL git invocations go through
 // this: an argument from the model can never be seen by a shell, so $(...),
 // backticks and a leading `-` (option injection) cannot turn a read-only call
@@ -22,7 +26,7 @@ export function runGitArgs(args, cwd, timeout = 15_000) {
             const errStr = (stderr || '').toString();
             if (!err) {
                 const combined = (out + errStr).trim();
-                resolve(combined || '(command produced no output)');
+                resolve(combined || NO_OUTPUT_SENTINEL);
                 return;
             }
             const parts = [];
@@ -49,7 +53,11 @@ export async function getGitContext(workdir) {
     const remoteR = await runGitArgs(['remote'], workdir, 5000);
     const aheadR = await runGitArgs(['rev-list', '--left-right', '--count', '@{upstream}...HEAD'], workdir, 5000);
     const branch = branchR.trim() || '(detached HEAD)';
-    const statusLines = statusR
+    // The shared runner answers an EMPTY successful run with a sentinel. Storing
+    // it verbatim told the model the tree had a modified "file" that is really
+    // an internal string — every task started with a false dirty-tree premise.
+    const statusText = statusR.trim() === NO_OUTPUT_SENTINEL ? '' : statusR;
+    const statusLines = statusText
         .split(String.fromCharCode(10))
         .map((l) => l.trimEnd())
         .filter(Boolean);
@@ -84,7 +92,7 @@ export function formatGitContext(ctx) {
     else {
         s += '\n- Remote: (none)';
     }
-    if (ctx.changedFiles > 0) {
+    if (ctx.changedFiles > 0 && ctx.statusPreview.trim() !== NO_OUTPUT_SENTINEL) {
         s += `\n- Uncommitted changes: ${ctx.changedFiles} file(s)
 `;
         // Choose a fence longer than any backtick run in the preview: a filename
@@ -234,8 +242,7 @@ export function createGitTools(workdir) {
                 // We stage everything only if the index is empty (as the description promises).
                 const staged = await runGitArgs(['diff', '--cached', '--name-only'], workdir, 10_000);
                 const stagedTrimmed = staged.trim();
-                const hasStaged = stagedTrimmed !== '' &&
-                    stagedTrimmed !== '(command produced no output)';
+                const hasStaged = stagedTrimmed !== '' && stagedTrimmed !== NO_OUTPUT_SENTINEL;
                 const addResult = hasStaged
                     ? '(index is not empty — add -A skipped)'
                     : await runGitArgs(['add', '-A'], workdir, 20_000);

package/dist/goal.js

@@ -86,11 +86,34 @@ export function parseGoalVerdict(text) {
     // — the goal loop then auto-continued until the turn budget although the
     // judge had already said NOT_MET. `MET` is tried LAST so it cannot match the
     // tail of `NOT MET`.
-    const m = /VERDICT\s*[*_`]*\s*:\s*[*_`]*\s*(IMPOSSIBLE|NOT[_ -]?MET|MET)/i.exec(t);
-    if (!m)
+    //
+    // The evaluator sometimes ECHOES the requested label set before the real
+    // verdict (`VERDICT: MET | NOT_MET | IMPOSSIBLE`). Taking the FIRST match
+    // read the echo's `MET` as the verdict while REASON said the opposite, and
+    // MET CLEARS the goal — an unfinished task was silently accepted as done.
+    // A verdict line with a separator after the value is an echo, not a verdict;
+    // scan EVERY `VERDICT:` occurrence and take the first REAL one. The
+    // 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;
+    let m;
+    let status = null;
+    while ((m = label.exec(t)) !== null) {
+        // Skip whitespace/backticks between the value and whatever follows.
+        let k = m.index + m[0].length;
+        while (k < t.length && /[\s*_`]/.test(t.charAt(k)))
+            k++;
+        const after = t.charAt(k);
+        if (after === '|' || after === '/')
+            continue;
+        const raw = m[1].toUpperCase();
+        status =
+            raw === 'MET' ? 'met' : raw === 'IMPOSSIBLE' ? 'impossible' : 'not_met';
+        break;
+    }
+    if (!status)
         return null;
-    const raw = m[1].toUpperCase();
-    const status = raw === 'MET' ? 'met' : raw === 'IMPOSSIBLE' ? 'impossible' : 'not_met';
     const rm = /REASON\s*[*_`]*\s*:\s*(.+)/i.exec(t);
     const reason = rm
         ? rm[1]

package/dist/input/layout.js

@@ -59,15 +59,29 @@ export function pasteReplacement(raw) {
         return null;
     return { marker: formatPasteMarker(lines), text };
 }
-// Replace "[Pasted lines#N]" markers with the original pasted text (the first
-// occurrence in order — matches the order in which the pastes were inserted).
+// Replace "[Pasted lines#N]" markers with the original pasted text. The marker
+// carries ONLY the line count, so two pastes of the same length share it: a
+// plain indexOf-per-paste substituted the FIRST paste's text into whichever
+// marker survived (the operator deleted the first one) — the model then got
+// the WRONG paste under a plausible marker. Replacing ONE occurrence per paste
+// and tying each marker to the pasted text it was CREATED with fixes it for
+// every order: an unmatched paste leaves the marker as text instead of
+// swapping bodies.
 export function expandPastes(pastes, text) {
-    let out = text;
-    for (const p of pastes) {
-        const idx = out.indexOf(p.marker);
-        if (idx !== -1) {
-            out = out.slice(0, idx) + p.text + out.slice(idx + p.marker.length);
-        }
+    if (!pastes.length)
+        return text;
+    // Expand in REVERSE order of appearance: each paste consumes its OWN marker
+    // occurrence (the last one for the last paste), so a marker the operator
+    // deleted cannot shift another paste's text into the wrong slot. With a
+    // single occurrence left, the LAST paste owns it — the operator deleted the
+    // EARLIER marker, so the later paste's body is the right fill.
+    let out = String(text);
+    for (let i = pastes.length - 1; i >= 0; i--) {
+        const p = pastes[i];
+        const idx = out.lastIndexOf(p.marker);
+        if (idx === -1)
+            continue;
+        out = out.slice(0, idx) + p.text + out.slice(idx + p.marker.length);
     }
     return out;
 }

package/dist/input/suggest.js

@@ -100,10 +100,23 @@ export function completeSlashCommand(buf, sugg, selected) {
     if (sugg.length === 1)
         return sugg[0].name + ' ';
     let prefix = sugg[0].name;
+    const typed = buf.toLowerCase();
     for (const c of sugg) {
-        while (!c.name.toLowerCase().startsWith(prefix.toLowerCase())) {
+        while (prefix.length > typed.length &&
+            !c.name.toLowerCase().startsWith(prefix.toLowerCase())) {
             prefix = prefix.slice(0, -1);
         }
     }
+    // Stop shrinking at the TYPED text: with an empty buffer the list matches
+    // everything, and the shared prefix used to shrink down to a bare "/" (or a
+    // common first letter like "/h") — Tab then inserted something the operator
+    // never typed. A completion must EXTEND what is already there.
+    // With an EMPTY buffer everything matches and the shared prefix collapses
+    // to a bare "/" (or a common first letter like "/h"): Tab must not guess a
+    // command the operator has not started typing.
+    if (typed.length < 2)
+        return null;
+    if (!prefix.toLowerCase().startsWith(typed))
+        return null;
     return prefix.length > buf.length ? prefix : null;
 }

package/dist/net-capture.js

@@ -169,9 +169,12 @@ export function extractAnswer(body) {
 // isFinishedWithoutAnswer === false): the finish loop kept polling for a
 // complete answer and `ask()` gave up only at the askDeadlineMs watchdog — the
 // operator watched a spinner for ~4 minutes with no tool call.
-// A real answer (a tool-call JSON, prose, a `respond` call) is far longer, so
-// anything below this is treated as a truncated/empty turn and retried.
-const MIN_FINISHED_ANSWER_CHARS = 4;
+// A real answer is anything non-empty. The one case that must NOT count is a
+// truncated RESPONSE head (an empty string or a bare `{`), which the measure
+// below excludes explicitly.
+const MIN_REAL_ANSWER_CHARS = 1;
+/** A bare truncated head (whitespace or braces only) is not a real answer. */
+const TRUNCATED_HEAD_RE = /^[\s{[]*$/;
 // How many chars of RESPONSE text the body carries, or -1 when there is NO
 // RESPONSE fragment at all. The fragment is SSE/JSON-encoded, so the content
 // may contain `\"` escapes AND raw `"` inside the JSON (the capture is the RAW
@@ -184,7 +187,25 @@ function responseContentLength(body) {
     const b = String(body || '');
     if (!/"type":"RESPONSE"/.test(b))
         return -1;
-    return extractFromSse(b).length;
+    // `extractFromSse` reads only `data:` lines, so a plain-JSON body (or one
+    // captured without the SSE framing) measured as 0 even when it carried a
+    // real SHORT answer. Count the content strings from the raw body and decode
+    // them, so an escaped quote does not inflate the count.
+    let len = 0;
+    const re = /"type":"RESPONSE"[^}]*?"content":"((?:[^"\\]|\\.)*)"/g;
+    let m;
+    while ((m = re.exec(b)) !== null) {
+        let text = m[1];
+        try {
+            text = JSON.parse('"' + m[1] + '"');
+        }
+        catch { }
+        // A bare truncated head (empty, or a lone `{`/`[`) is not an answer; any
+        // other non-empty text — however short — is.
+        if (!TRUNCATED_HEAD_RE.test(text))
+            len += text.length;
+    }
+    return len;
 }
 // True when the SSE body shows a turn that ENDED (`quasi_status: FINISHED`)
 // but produced NO real answer text — the reasoning (THINK fragment) was
@@ -209,7 +230,7 @@ export function isFinishedWithoutAnswer(body) {
         return false;
     // A RESPONSE fragment with real content means the model DID answer.
     const len = responseContentLength(b);
-    if (len >= MIN_FINISHED_ANSWER_CHARS)
+    if (len >= MIN_REAL_ANSWER_CHARS)
         return false;
     // No RESPONSE fragment at all (len === -1) or only a truncated head:
     // treat the absence of a real answer as "no answer produced".
@@ -234,7 +255,7 @@ export function isFinishedWithAnswer(body) {
     // A truncated RESPONSE head (a lone `{`) is NOT a complete answer: the
     // finish loop would return it as the model's text and the tool-call parser
     // would fail on it. Require real content (see MIN_FINISHED_ANSWER_CHARS).
-    return responseContentLength(b) >= MIN_FINISHED_ANSWER_CHARS;
+    return responseContentLength(b) >= MIN_REAL_ANSWER_CHARS;
 }
 // The CONTEXT size (in tokens) DeepSeek reports for the current answer.
 //

package/dist/permissions.js

@@ -80,9 +80,22 @@ function looksLikePath(v) {
 export function collectPathCandidates(tool, args) {
     const a = (args ?? {});
     const out = [];
+    // A path may arrive as a STRING or as an ARRAY of strings (`files: [...]`,
+    // `path: [...]`), and MCP tools nest their args (`{file: {path}}`). Accepting
+    // only a top-level string let a `path` deny rule be bypassed by wrapping the
+    // same path one level deeper or in an array.
+    const addValue = (v) => {
+        if (typeof v === 'string')
+            out.push(v);
+        else if (Array.isArray(v)) {
+            for (const x of v)
+                if (typeof x === 'string')
+                    out.push(x);
+        }
+    };
     for (const k of PATH_KEYS) {
-        if (typeof a[k] === 'string')
-            out.push(a[k]);
+        if (k in a)
+            addValue(a[k]);
     }
     if (tool === 'ApplyPatch') {
         // Parse the patch and pull the file headers out of it.
@@ -96,13 +109,33 @@ export function collectPathCandidates(tool, args) {
         while ((m = re.exec(text)))
             out.push(m[1]);
     }
-    // MCP tools (and any unknown tool): scan the string values for path-looking
-    // entries. Conservative — only values that clearly look like paths.
+    // MCP tools (and any unknown tool): scan the values for path-looking
+    // entries — through ARRAYS and NESTED objects too, since an MCP schema is
+    // free to nest (`{file: {path}}`) or take `argv: ['cat', '/etc/x']`. Only
+    // values that clearly look like paths are taken (depth-bounded to avoid a
+    // pathological payload).
     if (tool.includes('__')) {
-        for (const v of Object.values(a)) {
-            if (typeof v === 'string' && looksLikePath(v))
-                out.push(v);
-        }
+        const walk = (v, depth) => {
+            if (depth > 4 || v === null || v === undefined)
+                return;
+            if (typeof v === 'string') {
+                if (looksLikePath(v))
+                    out.push(v);
+                return;
+            }
+            if (Array.isArray(v)) {
+                for (const x of v)
+                    walk(x, depth + 1);
+                return;
+            }
+            if (typeof v === 'object') {
+                for (const x of Object.values(v)) {
+                    walk(x, depth + 1);
+                }
+            }
+        };
+        for (const v of Object.values(a))
+            walk(v, 0);
     }
     return out;
 }
@@ -124,6 +157,13 @@ export function decidePermission(policy, tool, args) {
     }
     const paths = collectPathCandidates(tool, args);
     for (const r of policy.rules) {
+        // An UNPARSABLE regex in any field of the rule makes the rule fail
+        // CLOSED: skipping it silently (the old behavior) turned a deny rule with
+        // a typo (`^(Bash$`) into "allow everything it was meant to block".
+        const bad = [r.tool, r.command, r.path].find((src) => src !== undefined && safeRegex(src) === null);
+        if (bad !== undefined) {
+            return { action: 'deny', reason: 'rule has an invalid regex: ' + bad };
+        }
         if (r.tool) {
             const re = safeRegex(r.tool);
             if (!re || !re.test(tool))

package/dist/qwen-chats.js

@@ -101,18 +101,33 @@ export function parseQwenChatList(json) {
                 data.list ??
                 data.items)
             : null;
-    if (!Array.isArray(arr))
+    // The payload has also been seen as a MAP keyed by chat id (the same
+    // convention as the history shape); the key then IS the id. Without this a
+    // legitimate list was rejected by the array guard and /chats printed
+    // "(none)" with no error.
+    const keyed = Array.isArray(arr)
+        ? null
+        : arr && typeof arr === 'object'
+            ? Object.entries(arr)
+            : null;
+    if (!Array.isArray(arr) && !keyed)
         return [];
+    const entries = Array.isArray(arr)
+        ? arr.map((c) => ['', c])
+        : keyed;
     const out = [];
-    for (const c of arr) {
+    for (const [key, c] of entries) {
         if (!c || typeof c !== 'object')
             continue;
         const m = c;
-        const id = typeof m.id === 'string'
-            ? m.id
-            : typeof m.chat_id === 'string'
-                ? m.chat_id
-                : '';
+        // A numeric id (`{id: 12345}`) used to be dropped as "no id"; it is a
+        // perfectly usable chat id once stringified.
+        const raw = m.id ?? m.chat_id;
+        const id = typeof raw === 'string'
+            ? raw
+            : typeof raw === 'number' && Number.isFinite(raw)
+                ? String(raw)
+                : key;
         if (!id)
             continue;
         const title = (typeof m.title === 'string' && m.title) ||
@@ -163,14 +178,23 @@ export function parseQwenHistory(json) {
     const out = [];
     for (const m of sorted) {
         // Role detection is DEFENSIVE: the field has been `role` (string,
-        // case-insensitive), a numeric flag, or `is_user`. Anything that is not
+        // case-insensitive), a NUMERIC flag, or `is_user`. Anything that is not
         // clearly the user is treated as the assistant (the restored dialogue
-        // cares about the distinction, not the exact enum).
+        // cares about the distinction, not the exact enum). A numeric flag uses
+        // 1 = user, 2 = assistant (the `String(1) === '1'` form was ignored and
+        // every user turn was attributed to the model).
         const roleStr = String(m.role ?? '').toLowerCase();
+        // `from` is matched case-insensitively and accepts Qwen's `human`
+        // spelling: the exact `from === 'user'` test read an uppercase/human
+        // turn as the ASSISTANT's answer, so the operator's own question was
+        // restored as the model's reply.
+        const fromStr = String(m.from ?? '').toLowerCase();
         const isUser = roleStr === 'user' ||
+            roleStr === '1' ||
             roleStr === '0' ||
             m.is_user === true ||
-            m.from === 'user';
+            fromStr === 'user' ||
+            fromStr === 'human';
         const role = isUser ? 'user' : 'assistant';
         let text = '';
         if (typeof m.content === 'string')

package/dist/qwen-net-capture.js

@@ -184,7 +184,12 @@ export function isFinishedWithoutAnswer(body) {
         for (const ch of choices) {
             if (!ch || typeof ch !== 'object')
                 continue;
-            const delta = ch.delta;
+            const c = ch;
+            // The final chunk carries `status` on the CHOICE (see the format comment
+            // at the top of this file); older/other builds put it on `delta`.
+            if (c.status === 'finished')
+                finished = true;
+            const delta = c.delta;
             if (delta && delta.status === 'finished')
                 finished = true;
         }

package/dist/scheduler.js

@@ -56,7 +56,13 @@ function dayMatches(c, date) {
 function parseCronField(field, min, max) {
     const out = new Set();
     for (const part of field.split(',')) {
-        const [range, stepStr] = part.split('/');
+        // An empty list item (`1,,2`, a trailing comma) used to fall through
+        // Number('') === 0 and silently ADD minute 0 to the schedule.
+        if (!part)
+            return null;
+        const [range, stepStr, extra] = part.split('/');
+        if (extra !== undefined)
+            return null;
         const step = stepStr === undefined ? 1 : Number(stepStr);
         if (!Number.isInteger(step) || step <= 0)
             return null;
@@ -67,11 +73,22 @@ function parseCronField(field, min, max) {
             hi = max;
         }
         else if (range.includes('-')) {
-            const [a, b] = range.split('-');
+            // A bare number is required on BOTH sides: `split('-')` on `-5` gave
+            // ['', '5'] and Number('') === 0, so a typo `-5 * * * *` became the
+            // range 0-5 instead of being rejected. `1-2-3` was silently truncated
+            // to 1-2 the same way.
+            const segs = range.split('-');
+            if (segs.length !== 2)
+                return null;
+            const [a, b] = segs;
+            if (!/^\d+$/.test(a) || !/^\d+$/.test(b))
+                return null;
             lo = Number(a);
             hi = Number(b);
         }
         else {
+            if (!/^\d+$/.test(range))
+                return null;
             lo = Number(range);
             // `N/step` (a start with a step, no range) is valid cron: it means from
             // N up to the field maximum. Treating it as the single value N made a

package/dist/shell.js

@@ -25,7 +25,12 @@ export function assertCommandInsideRoot(root, command) {
     }
     // `(` and backticks open a subshell / command substitution where a `cd` is
     // still executed; include them in the prefix so the scan sees it.
-    const cdRe = /(?:^|[;&|(\s`])(?:cd|pushd)\s+([^;&|)]+)/gi;
+    //
+    // `\s*` (not `\s+`): a shell accepts `cd` GLUED to its target — `cd..`,
+    // `cd$HOME`, `cd../..` — and runs it as a real directory change. Requiring
+    // whitespace skipped those forms, so a glued `cd../..` walked out of the
+    // root with the guard never firing.
+    const cdRe = /(?:^|[;&|(\s`])(?:cd|pushd)\s*([^;&|)]+)/gi;
     let m;
     while ((m = cdRe.exec(cmd))) {
         const raw = m[1].trim().replace(/^["']|["']$/g, '');
@@ -217,6 +222,22 @@ export function killBackground(id) {
         return `Failed to kill ${id}: ${e.message}`;
     }
     BG_PROCS.delete(id);
+    // SIGTERM is only a REQUEST. A shell that traps it (a wrapper script, a
+    // daemon that cleans up on TERM) ignores the signal, and the old code then
+    // forgot the id and reported "Killed" while the process kept running as an
+    // orphan. Give it a moment, then SIGKILL the group (the shell's own trap
+    // cannot block that). Detached from the caller so killBackground stays sync.
+    const pid = p.child.pid;
+    if (process.platform !== 'win32' && pid) {
+        const t = setTimeout(() => {
+            try {
+                process.kill(-pid, 'SIGKILL');
+            }
+            catch { }
+        }, 1500);
+        if (typeof t.unref === 'function')
+            t.unref();
+    }
     return `Killed background process ${id}.`;
 }
 /** Kill every background process — called on exit so no orphan survives. */

package/dist/tools.js

@@ -71,7 +71,8 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
     const baseTools = [
         {
             name: 'Read',
-            description: 'Read a file. Optional: offset and limit (lines). ' +
+            description: 'Read a file. Optional: offset and limit (lines, BOTH 1-BASED: ' +
+                'offset=5 starts at line 5, limit=10 reads ten lines). ' +
                 'numbered=true adds cat -n style line numbers (1-based) for reference ' +
                 'only — do NOT copy the numbers into Edit old_string. ' +
                 'Lines longer than 2000 chars are truncated. ' +
@@ -117,8 +118,15 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
                 if (content === '')
                     return '(file is empty)';
                 const lines = content.split('\n');
-                const start = offset ?? 0;
-                const end = limit ? start + limit : lines.length;
+                // `offset`/`limit` are 1-BASED, like sed / `git blame -L` and the
+                // `numbered=true` output this tool prints. Treating them as 0-based
+                // array slices silently shifted every window by one line and made
+                // `offset: 1` skip the first line. A non-positive or non-numeric
+                // offset means "from the start".
+                const off = Math.max(1, Math.floor(Number(offset) || 1));
+                const start = off - 1;
+                const lim = Math.floor(Number(limit));
+                const end = Number.isFinite(lim) && lim > 0 ? start + lim : lines.length;
                 const slice = lines.slice(start, end);
                 const clip = (l) => l.length > 2000 ? clipLine(l, 2000) + ' …[line truncated]' : l;
                 if (!numbered)

package/dist/transcript.js

@@ -1,5 +1,8 @@
 import fs from 'fs';
 import path from 'path';
+function transcriptErrorLine(e) {
+    return `transcript: failed to create file: ${e.message}`;
+}
 export class Transcript {
     enabled;
     file;
@@ -17,7 +20,14 @@ export class Transcript {
         try {
             fs.mkdirSync(dir, { recursive: true });
             const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-            this.file = path.join(dir, `${sessionName}-${stamp}.jsonl`);
+            // `sessionName` is the LABEL of the working directory (dirLabel), so a
+            // name like `a/b` or `C:\x` would nest a subdirectory or break the
+            // path outright: the stream then failed with ENOENT and no transcript
+            // at all was written. Keep the name a plain file-name fragment.
+            const safeName = String(sessionName)
+                .replace(/[\\/:*?"<>|\u0000-\u001f]/g, '_')
+                .trim() || 'session';
+            this.file = path.join(dir, `${safeName}-${stamp}.jsonl`);
             this.stream = fs.createWriteStream(this.file, { flags: 'a' });
             // Write errors (disk full, file deleted, etc.) arrive as an 'error'
             // event; without a listener this is an uncaught exception.
@@ -27,10 +37,12 @@ export class Transcript {
             });
         }
         catch (e) {
-            console.error(`transcript: failed to create file: ${e.message}`);
+            console.error(transcriptErrorLine(e));
             this.enabled = false;
         }
     }
+    /** Number of writes that hit backpressure (write() === false). */
+    backpressure = 0;
     log(type, data = {}) {
         const entry = {
             ts: new Date().toISOString(),
@@ -60,8 +72,6 @@ export class Transcript {
         }
         catch { }
     }
-    /** Number of writes that hit backpressure (write() === false). */
-    backpressure = 0;
     // Flush the stream and resolve once the data reached the file. The callers
     // run on process.exit paths (one-shot --task, browser error, clean exit), and
     // end() without awaiting the callback lets the process die before the buffer
@@ -89,6 +99,6 @@ export class Transcript {
             return null;
         return ('transcript: ' +
             this.backpressure +
-            ' write(s) hit backpressure (slow disk?) — events may be delayed');
+            ' write(s) hit backpressure (slow disk?)― events may be delayed');
     }
 }

package/dist/web.js

@@ -38,10 +38,17 @@ export function htmlToText(html) {
     pendingHighSurrogate = null;
     // Remove blocks we don't need
     let s = html
+        // A tag that never CLOSES (a truncated body, or HTML the regex cannot
+        // pair) used to leak its raw JS/CSS into the text: also drop everything
+        // from an unclosed opening tag to the end of the document.
         .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<script\b[\s\S]*$/i, '')
         .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/<style\b[\s\S]*$/i, '')
         .replace(/<noscript[\s\S]*?<\/noscript>/gi, '')
+        .replace(/<noscript\b[\s\S]*$/i, '')
         .replace(/<svg[\s\S]*?<\/svg>/gi, '')
+        .replace(/<svg\b[\s\S]*$/i, '')
         .replace(/<!--[\s\S]*?-->/g, '');
     // Links: <a href="URL">text</a> → text (URL)
     s = s.replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text) => {
@@ -219,6 +226,28 @@ export function isPrivateIp(ip) {
         // ff00::/8 multicast is not a public unicast destination either.
         if ((g0 & 0xff00) === 0xff00)
             return true;
+        // 6to4 (2002:AABB:CCDD::/48) embeds an IPv4 in groups 1-2, so
+        // `2002:7f00:0001::` IS 127.0.0.1 and `2002:a9fe:a9fe::` is the cloud
+        // metadata address. Judged by the embedded address, like the other
+        // transition prefixes.
+        if (v6[0] === 0x2002) {
+            return isPrivateIp((v6[1] >> 8) +
+                '.' +
+                (v6[1] & 0xff) +
+                '.' +
+                (v6[2] >> 8) +
+                '.' +
+                (v6[2] & 0xff));
+        }
+        // Teredo (2001:0000::/32): the CLIENT IPv4 is the last 32 bits XORed with
+        // 0xffffffff (the server IPv4 sits in groups 3-4 and is not the peer).
+        if (v6[0] === 0x2001 && v6[1] === 0x0000) {
+            const a = (v6[6] >> 8) ^ 0xff;
+            const b = (v6[6] & 0xff) ^ 0xff;
+            const c = (v6[7] >> 8) ^ 0xff;
+            const d = (v6[7] & 0xff) ^ 0xff;
+            return isPrivateIp(a + '.' + b + '.' + c + '.' + d);
+        }
         // IPv4-mapped ::ffff:a.b.c.d — judge the embedded address.
         const mappedV4 = v6.slice(0, 5).every((g) => g === 0) && v6[5] === 0xffff;
         if (mappedV4) {
@@ -618,7 +647,11 @@ export function parseDuckDuckGoResults(body, limit) {
             href = decodeURIComponent(uddgMatch[1]);
         const title = htmlToText(m[2] || '').trim();
         const snippet = htmlToText(m[3] || '').trim();
-        if (!title || !href)
+        // Only an absolute http(s) link is a real result. The page can carry a
+        // `javascript:`/`data:` href (malicious or broken markup) or a
+        // site-relative one; handing either to the model as a result URL is wrong
+        // (a `javascript:` URL looks fetchable, a relative one is not).
+        if (!title || !/^https?:\/\//i.test(href))
             continue;
         results.push({ title, url: href, snippet });
     }

package/dist/xml-toolcall.js

@@ -46,13 +46,29 @@ function readAllAttrs(attrs) {
 // (the agent then stalls). Here we look for the first JSON object inside the
 // attributes/body and parse it as args.
 function parseInlineJsonArgs(s) {
+    // Find the start of the inline JSON. The SPECIFIC `"args" {` marker wins:
+    // a generic `{` in the surrounding prose (`note {here}: {…}`) was taken as
+    // the object start, balance ended on its `}`, and the call reached the tool
+    // with EMPTY args. Fall back to a bare `{` only when the marker is absent.
+    const argsMarker = /["']args["']\s*[:=]?\s*\{/i.exec(s);
+    if (argsMarker)
+        return parseBalancedJson(s, argsMarker.index + argsMarker[0].length - 1);
+    // No explicit marker: try EVERY `{` and take the first one that actually
+    // parses as an object. Picking the first `{` blindly broke on a stray brace
+    // in the prose (`note {here}: {…}`): balance ended on its `}`, the fragment
+    // carried no arguments, and the tool ran with EMPTY args.
+    const re = /\{/g;
+    let b;
+    while ((b = re.exec(s)) !== null) {
+        const parsed = parseBalancedJson(s, b.index);
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+/** Parse one balanced, string-aware `{...}` object that STARTS at `from`. */
+function parseBalancedJson(s, from) {
     const Q = String.fromCharCode(34);
-    // Find a plausible start of a JSON object: `{` or `"args" {`/`'args' {`.
-    const startRe = /\{|["']args["']\s*[:=]?\s*\{/i;
-    const m = startRe.exec(s);
-    if (!m)
-        return null;
-    const from = m.index;
     // Scan for a balanced {...} block (string-aware) and try to parse it.
     let depth = 0;
     let inStr = false;
@@ -112,14 +128,47 @@ function parseInlineJsonArgs(s) {
 // parameter).
 function parseParameters(body) {
     const args = {};
-    const paramRe = /<[^>]*?parameter([^>]*)>([\s\S]*?)<\/[^>]*?parameter[^>]*>/gi;
-    let p;
-    while ((p = paramRe.exec(body)) !== null) {
-        const pname = readAttr(p[1] || '', 'name');
+    // The VALUE is arbitrary model text: a Write/Edit content may legitimately
+    // contain the literal `</parameter>` (writing an XML parser, a docs
+    // example). A plain non-greedy scan stops at that FIRST close tag and the
+    // rest of the content is silently lost — the file is written TRUNCATED.
+    // So: find every opening tag, then take as the value everything up to the
+    // LAST close tag of the same name that precedes the next opening tag (or the
+    // end of the body). A stray `</parameter>` inside a value is thus kept.
+    // An opening tag is `<parameter …>` / `<|DSML|parameter …>` — NOT the
+    // closing `</parameter>`, whose name ALSO matches this pattern (the prefix
+    // before `parameter` is not required to be empty). Treating a close tag as
+    // an open one shifted every limit by one element and cut the last value;
+    // a slash directly before `parameter` marks the close form.
+    const openRe = /<[^>]*?(?<!\/)parameter([^>]*)>/gi;
+    const opens = [];
+    let m;
+    while ((m = openRe.exec(body)) !== null) {
+        opens.push({
+            attrs: m[1] || '',
+            start: m.index,
+            valueStart: m.index + m[0].length,
+        });
+    }
+    const closeRe = /<\/[^>]*?parameter[^>]*>/gi;
+    for (let i = 0; i < opens.length; i++) {
+        const o = opens[i];
+        const pname = readAttr(o.attrs, 'name');
         if (!pname)
             continue;
-        const isString = /string[ ]*=[ ]*"?true"?/i.test(p[1] || '');
-        let value = unescapeXml(p[2]);
+        const limit = i + 1 < opens.length ? opens[i + 1].start : body.length;
+        // The LAST close tag before the next opening tag (or the end).
+        let valueEnd = limit;
+        closeRe.lastIndex = o.valueStart;
+        let c;
+        while ((c = closeRe.exec(body)) !== null) {
+            if (c.index >= limit)
+                break;
+            valueEnd = c.index;
+        }
+        const raw = body.slice(o.valueStart, valueEnd);
+        const isString = /string[ ]*=[ ]*"?true"?/i.test(o.attrs);
+        let value = unescapeXml(raw);
         if (!isString) {
             try {
                 value = JSON.parse(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.78.2",
+  "version": "2.79.0",
   "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": {