zames_pro 2.78.1 → 2.78.3

package/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+
+- **goal:** clampGoalCondition does not cut a surrogate pair
+- **web:** judge the expanded IPv6 form in the SSRF guard
+- **permissions:** match a command rule against an avv array
+- **scheduler:** OR a restricted day-of-month and day-of-week
+- **qwen:** guest-limit classifier ignores a normal answer
+- **net-capture:** read a top-level accumulated_token_usage pair
+- **tools:** Read does not clip a surrogate pair in half
+- **tool-summary:** do not cut a surrogate pair in the log line
+- **shell:** do not start a background trim on a lone surrogate
+- **sandbox:** match eval at a command position, not as a substring
+- **goal:** parse the spaced and hyphenated NOT MET verdict
+- **hooks:** cap the combined PostToolUse and lifecycle output
+- **fsutil:** write atomic files through a symlink, not over it
+- **mcp:** sanitize the server half of a qualified tool name
+- **statusline:** settle on our own stdout end, not on the pipe closing
+- **provider:** match the handoff workdir by real path, not by string
+- **checkpoint:** retention deletes same-millisecond sibling archives
+- **undo:** a missing backup file no longer wedges the undo history
+- **sessions:** a stale internal id no longer hides the saved session
+- **attach:** keep @file references inside the sandbox root
+
 ## [2.78.1] - 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/attach-refs.js

@@ -9,6 +9,15 @@ const NL = String.fromCharCode(10);
 // Resolve a pasted string into a path to an EXISTING file. Handles quoted
 // paths (drag&drop from some file managers adds quotes) and paths relative to
 // the working directory. Returns null when nothing matches.
+//
+// Every candidate is checked against the sandbox root (the REAL path, so
+// a symlink escape is refused too). The `..`/cwd candidates exist to help an
+// operator paste a path that LOOKS relative to the project, not to grant
+// access above it: without this guard a reference with a `..` inlined a file
+// outside the sandbox, while every other file tool rejects that path via
+// safePath(). The search continues past an escaping candidate (a regular
+// file inside the project must still resolve), but no candidate outside is
+// ever returned.
 export async function resolveAttachPath(workdir, raw) {
     let s = String(raw || '').trim();
     if (!s)
@@ -34,11 +43,25 @@ export async function resolveAttachPath(workdir, raw) {
         ];
     for (const c of candidates) {
         const st = await fs.stat(c).catch(() => null);
-        if (st && st.isFile())
+        if (!st || !st.isFile())
+            continue;
+        if (await isInside(workdir, c))
             return c;
     }
     return null;
 }
+// True when the REAL path of `target` stays under the REAL workdir root.
+// realpath (not the lexical path) is required here for the same reason as
+// safePath() in src/sandbox.ts: a symlink inside the project can point
+// outside it.
+async function isInside(workdir, target) {
+    const root = await fs.realpath(path.resolve(workdir)).catch(() => null);
+    const real = await fs.realpath(target).catch(() => null);
+    if (!root || !real)
+        return false;
+    const rel = path.relative(root, real);
+    return !rel.startsWith('..') && !path.isAbsolute(rel);
+}
 // Per-file and total caps for `@path` inlining (B5). A reference should SAVE
 // round-trips, not flood the context: a huge file is truncated with a note
 // telling the agent to read the rest itself.

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

@@ -176,10 +176,14 @@ export class CheckpointStore {
         const history = await this._readIndex();
         history.push(record);
         const kept = rotateRecords(history, this.maxBackups);
-        // Drop the archives that fell out of the retention window.
-        const keptStamps = new Set(kept.map((r) => r.stamp));
+        // Drop the archives that fell out of the retention window. Keyed by the
+        // RECORD, not by its stamp: the stamp is ms-precision, so two snapshots of
+        // one workdir taken in the same millisecond share it — the pruned record
+        // then looked "kept" thanks to its sibling and its archive stayed on disk
+        // as an orphan forever.
+        const keptSet = new Set(kept);
         for (const r of history) {
-            if (!keptStamps.has(r.stamp))
+            if (!keptSet.has(r))
                 await fs.rm(r.file, { force: true }).catch(() => { });
         }
         writeJsonAtomic(this.indexFile, kept);

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

@@ -16,7 +16,18 @@ import path from 'path';
 // multi-user machine. We also chmod the target after rename because a
 // pre-existing file keeps its old mode (rename does not change the inode).
 export function writeFileAtomic(file, data) {
-    const tmp = file + '.tmp-' + process.pid;
+    // Follow a SYMLINK first: a dotfiles setup links ~/.zames/config.json into a
+    // git repo, and a project may link .zamesrc.json. Renaming a temp file over
+    // the link replaces the LINK with a regular file — the real target keeps the
+    // stale content and the next launch reads what the operator never edited.
+    let target = file;
+    try {
+        target = fs.realpathSync(file);
+    }
+    catch {
+        // Missing (first write) or broken link: write to the path itself.
+    }
+    const tmp = target + '.tmp-' + process.pid;
     // fsync the file BEFORE rename: without it a power loss can leave the
     // renamed name pointing at an empty/partial inode (rename itself is atomic,
     // but the data blocks may not have reached the disk yet).
@@ -29,7 +40,7 @@ export function writeFileAtomic(file, data) {
         finally {
             fs.closeSync(fd);
         }
-        fs.renameSync(tmp, file);
+        fs.renameSync(tmp, target);
     }
     catch (e) {
         // A failed write/fsync/rename (full disk, EIO, a directory in the way)

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

@@ -13,7 +13,14 @@ export function clampGoalCondition(condition) {
     const g = String(condition ?? '').trim();
     if (g.length <= GOAL_CONDITION_CAP)
         return g;
-    return g.slice(0, GOAL_CONDITION_CAP);
+    // Never cut a surrogate PAIR in half: the condition is injected into the
+    // evaluator prompt, and a lone high surrogate is a broken code point (same
+    // rule as truncateToolResult / capReport / clipLine / oneLine).
+    let cut = GOAL_CONDITION_CAP;
+    const last = g.charCodeAt(cut - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        cut--;
+    return g.slice(0, cut);
 }
 // The evaluator prompt is AGENT-facing (English), like the system prompt and
 // the compact summary prompt. It runs in the SAME chat as the work so the
@@ -74,7 +81,12 @@ export function parseGoalVerdict(text) {
     // spaces (`**VERDICT:** MET`) — a markdown-model answer did exactly that and
     // the strict `VERDICT:` matcher returned null, so the goal never parsed and
     // the loop auto-continued until the turn budget.
-    const m = /VERDICT\s*[*_`]*\s*:\s*[*_`]*\s*(MET|NOT_MET|IMPOSSIBLE)/i.exec(t);
+    // The value itself may be written the human way (`NOT MET`, `NOT-MET`): a
+    // strict `NOT_MET` matcher returned null for those, and null means "continue"
+    // — 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)
         return null;
     const raw = m[1].toUpperCase();

package/dist/hooks.js

@@ -15,6 +15,9 @@ const HOOK_MAX_BUFFER = 1024 * 1024;
 // A PreToolUse denial becomes the tool result the model reads, so it is capped
 // like any other tool output.
 const HOOK_DENIAL_CAP = 4000;
+// Combined stdout of a PostToolUse / lifecycle hook. It lands in a tool result
+// or in the chat, so it is a notice, not a log dump.
+const HOOK_OUTPUT_CAP = 8000;
 export function hooksConfigPath(workdir) {
     return path.join(workdir, '.zames', 'hooks.json');
 }
@@ -181,13 +184,28 @@ export async function runLifecycleHooks(hooks, event, workdir, extra = {}) {
 async function runEventHooks(hooks, event, workdir, tool, args, result) {
     const list = hooks?.[event];
     const parts = [];
+    let total = 0;
     for (const entry of list ?? []) {
         if (!matchesHook(entry, tool))
             continue;
         const r = await runHook(entry, event, tool, args, workdir, result);
         const out = r.stdout.trim();
-        if (out)
-            parts.push(out);
+        if (!out)
+            continue;
+        // The combined output goes into a tool result (PostToolUse) or straight
+        // into the chat (SessionStart and the other lifecycle events), so it must
+        // stay a notice: a hook running `npm test` or dumping a log used to append
+        // hundreds of KB and flood the context.
+        if (total >= HOOK_OUTPUT_CAP)
+            break;
+        const piece = out.slice(0, HOOK_OUTPUT_CAP - total);
+        total += piece.length;
+        parts.push(piece);
     }
-    return parts.join(String.fromCharCode(10));
+    const joined = parts.join(String.fromCharCode(10));
+    if (joined.length <= HOOK_OUTPUT_CAP)
+        return joined;
+    return (joined.slice(0, HOOK_OUTPUT_CAP) +
+        String.fromCharCode(10) +
+        '… [hook output truncated]');
 }

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

@@ -275,7 +275,13 @@ function safeJson(v) {
 // servers cannot collide. The prefix uses __ (double underscore) because
 // the model must be able to reproduce it exactly.
 export function qualifyToolName(server, tool) {
-    return server + '__' + tool.replace(/[^A-Za-z0-9_]/g, '_');
+    // BOTH halves must be sanitized: a server name with a space ('my server')
+    // produced 'my server__tool', which the model cannot reproduce in a JSON
+    // tool call. The same rule on both sides also makes two spellings of one
+    // server collide on ONE qualified name, so dedupeToolNames can rename the
+    // duplicate instead of leaving both tools unreachable.
+    const clean = (s) => String(s || '').replace(/[^A-Za-z0-9_]/g, '_');
+    return clean(server) + '__' + clean(tool);
 }
 // Make every tool name unique IN PLACE. agent-loop resolves a call by name and
 // takes the first match, so a duplicate silently shadows the later tool. The

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.
 //
@@ -270,6 +291,12 @@ export function extractTokenUsage(body) {
             : undefined;
         if (resp)
             consider(resp.accumulated_token_usage);
+        // A BATCH update can also arrive with the pair at the TOP level:
+        // {"p":"accumulated_token_usage","v":N} (the same pair DeepSeek nests
+        // inside v: [...]). Reading only the nested form made the context counter
+        // silently stale for that stream shape.
+        if (o.p === 'accumulated_token_usage')
+            consider(o.v);
         // A BATCH update: v is an array of {"p":"accumulated_token_usage","v":N}.
         if (Array.isArray(o.v)) {
             for (const item of o.v) {

package/dist/permissions.js

@@ -110,9 +110,27 @@ export function decidePermission(policy, tool, args) {
     if (!policy)
         return { action: 'allow', reason: 'no policy' };
     const a = (args ?? {});
-    const commands = COMMAND_KEYS.filter((k) => typeof a[k] === 'string').map((k) => a[k]);
+    // A command may be a STRING (`command`, `cmd`, ...) or an ARRAY (`argv`,
+    // 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];
+        if (typeof v === 'string')
+            commands.push(v);
+        else if (Array.isArray(v)) {
+            commands.push(v.filter((x) => typeof x === 'string').join(' '));
+        }
+    }
     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/provider-handoff.js

@@ -52,7 +52,7 @@ export function readProviderHandoff(provider, workdir) {
         }
         if (raw.provider !== provider)
             return null;
-        if ((raw.workdir || '') !== (workdir || ''))
+        if (!sameDir(raw.workdir, workdir))
             return null;
         return raw;
     }
@@ -60,6 +60,30 @@ export function readProviderHandoff(provider, workdir) {
         return null;
     }
 }
+// Two paths that denote the SAME directory must match: the handoff is consumed
+// by the NEXT launch in that directory, and the path there is not guaranteed to
+// be byte-identical — a trailing separator (a `/cd sub/` leaves one) or a
+// symlinked route to the project used to make a lexical `!==` silently drop the
+// carried-over summary. realpath is the comparison; a missing dir falls back to
+// the resolved lexical path so a deleted project still matches its record.
+function sameDir(a, b) {
+    const x = String(a ?? '');
+    const y = String(b ?? '');
+    if (x === y)
+        return true;
+    if (!x || !y)
+        return false;
+    const real = (p) => {
+        const abs = path.resolve(p);
+        try {
+            return fs.realpathSync(abs);
+        }
+        catch {
+            return abs;
+        }
+    };
+    return real(x) === real(y);
+}
 /** Remove the handoff once it has been posted (or is stale). Best-effort. */
 export function clearProviderHandoff() {
     try {

package/dist/qwen-net-capture.js

@@ -256,6 +256,14 @@ export function isGuestLimitText(body) {
     const b = String(body || '');
     if (!b)
         return false;
+    // Same rule as isRateLimitText / isServerBusyText: a normal ANSWER may
+    // MENTION the guest limit (the model explaining Qwen's guest mode, a pasted
+    // notice). Only an error payload or a body with NO answer content can be the
+    // real notice; otherwise ask() would fail fast with "log in" and throw the
+    // answer away.
+    const errNotice = /event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b);
+    if (!errNotice && hasAnswerContent(b))
+        return false;
     return /guest chat limit|guest.*limit|log in to continue|гостевой лимит/i.test(b);
 }
 export function isServerBusyText(body) {

package/dist/scheduler.js

@@ -41,6 +41,17 @@ export function formatInterval(ms) {
         return ms / 1000 + 's';
     return ms + 'ms';
 }
+// The DAY rule of standard cron: when BOTH day-of-month and day-of-week are
+// restricted they are ORed (`0 9 1 * 1` = the 1st OR any Monday); otherwise
+// they are plain ANDed (an unrestricted field matches every day). ANDing a
+// restricted pair made the job fire only when the two coincided.
+function dayMatches(c, date) {
+    const domOk = c.dom.has(date.getDate());
+    const dowOk = c.dow.has(date.getDay());
+    if (c.domRestricted && c.dowRestricted)
+        return domOk || dowOk;
+    return domOk && dowOk;
+}
 // Parse one cron field ("*", "a-b", "*/n", "a,b", "a-b/n") into a value set.
 function parseCronField(field, min, max) {
     const out = new Set();
@@ -95,19 +106,26 @@ export function parseCron(expr) {
     const dow = new Set();
     for (const d of dowRaw)
         dow.add(d === 7 ? 0 : d);
-    return { minute, hour, dom, month, dow };
+    return {
+        minute,
+        hour,
+        dom,
+        month,
+        dow,
+        domRestricted: parts[2].trim() !== '*',
+        dowRestricted: parts[4].trim() !== '*',
+    };
 }
-// Does the given Date match the cron expression? dom and dow are ANDed (the
-// common, predictable behavior); to schedule "every day" use `*` for one.
+// Does the given Date match the cron expression? The day rule is standard
+// cron: dom/dow are ORed when BOTH are restricted, ANDed otherwise.
 export function cronMatches(expr, date) {
     const c = parseCron(expr);
     if (!c)
         return false;
     return (c.minute.has(date.getMinutes()) &&
         c.hour.has(date.getHours()) &&
-        c.dom.has(date.getDate()) &&
         c.month.has(date.getMonth() + 1) &&
-        c.dow.has(date.getDay()));
+        dayMatches(c, date));
 }
 // Next epoch ms at which the expression fires, strictly after `fromMs`. Scans
 // minute by minute (bounded to ~4 years); a one-time cost when a job is
@@ -125,9 +143,8 @@ export function nextCronTime(expr, fromMs) {
     while (d.getTime() <= limit) {
         if (c.minute.has(d.getMinutes()) &&
             c.hour.has(d.getHours()) &&
-            c.dom.has(d.getDate()) &&
             c.month.has(d.getMonth() + 1) &&
-            c.dow.has(d.getDay())) {
+            dayMatches(c, d)) {
             return d.getTime();
         }
         d.setMinutes(d.getMinutes() + 1);

package/dist/sessions.js

@@ -135,13 +135,17 @@ export function loadLastSession(workdir = '', provider) {
     try {
         const index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf-8'));
         const byWorkdir = index && index.byWorkdir ? index.byWorkdir : {};
-        const candidates = [byWorkdir[workdir], index.last].filter((x) => Boolean(x));
+        // A denylisted id is useless here: its subagent chat is never saved as a
+        // session, so a stale entry (recorded for a chat merely SEEN) would make the
+        // loop run out of candidates — even though the project's real session is
+        // right there on disk. Filter them out instead of `continue`-ing past them,
+        // then fall back to the newest saved session of this workdir so a stale
+        // index cannot make a saved chat unresumable.
         const internal = readInternal();
+        const candidates = [byWorkdir[workdir], index.last].filter((x) => Boolean(x) && !internal.has(String(x)));
         for (const id of candidates) {
             // The session file may have been deleted — the index is then stale and
             // the session cannot be restored. We try the next candidate.
-            if (internal.has(id))
-                continue;
             const s = readSession(id);
             if (!s)
                 continue;
@@ -151,7 +155,9 @@ export function loadLastSession(workdir = '', provider) {
                 continue;
             return s;
         }
-        return null;
+        const fallback = listSessions().find((s) => (!workdir || s.workdir === workdir) &&
+            (!provider || (s.provider || 'deepseek') === provider));
+        return fallback || null;
     }
     catch {
         return null;

package/dist/shell.js

@@ -12,12 +12,25 @@ export function assertCommandInsideRoot(root, command) {
     // eval re-parses its argument, so a `cd` hidden inside a string is invisible
     // to the static scan; refusing eval together with cd is the honest answer
     // instead of pretending the barrier still holds.
-    if (/\beval\b/.test(cmd) && /\bcd\b/.test(cmd)) {
+    //
+    // The test is on COMMAND POSITIONS, not on raw substrings: a bare
+    // `/eval/`+/cd/ matched ordinary text like `npx tsx --test
+    // test/goal-eval-unparsable.test.ts` (which DOES contain `cd` elsewhere, e.g.
+    // `cd proj && …`), so a legitimate command — even `npm test` — was rejected
+    // with a sandbox error. eval only re-parses when it is RUN, i.e. at the start
+    // of a command or after a separator, optionally via `sh -c eval …`.
+    const evalAtCommand = /(?:^|[;&|(]\s*|\bsh\s+-c\s+['"]?)\s*eval\b/;
+    if (evalAtCommand.test(cmd) && /\bcd\b/.test(cmd)) {
         throw new Error('Sandbox: eval with cd is forbidden');
     }
     // `(` 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, '');
@@ -118,10 +131,18 @@ const BG_PROCS = new Map();
 const BG_MAX_BUFFER = 1024 * 1024;
 function bgTrim(p) {
     if (p.out.length > BG_MAX_BUFFER) {
+        // Never START the kept window on a low surrogate: the cut slices a JS
+        // string, and an emoji / astral CJK char is TWO UTF-16 units, so a cut
+        // between them left a lone half at the head of the buffer that pollBackground
+        // hands to the model (same rule as truncateToolResult / capReport).
+        let start = p.out.length - BG_MAX_BUFFER;
+        const first = p.out.charCodeAt(start);
+        if (first >= 0xdc00 && first <= 0xdfff)
+            start++;
         p.out =
             '[...earlier output trimmed]' +
                 String.fromCharCode(10) +
-                p.out.slice(p.out.length - BG_MAX_BUFFER);
+                p.out.slice(start);
     }
 }
 /** Start a shell command in the background. Returns a short id. */
@@ -201,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/statusline.js

@@ -52,6 +52,15 @@ export function runStatusLineCommand(workdir, command, info, timeoutMs = 4000) {
             clearTimeout(timer);
             finish();
         });
+        // 'end' on OUR stdout fires as soon as the writer closes the pipe. 'close'
+        // waits for the pipes to drain, so a command that backgrounds a daemon (a
+        // watcher, `npm run dev &`) — whose grandchild inherits the pipe — kept the
+        // promise pending until the 4s timeout on EVERY tick even though the line
+        // had already been printed.
+        child.stdout?.on('end', () => {
+            clearTimeout(timer);
+            finish();
+        });
         child.on('close', () => {
             clearTimeout(timer);
             finish();

package/dist/tool-summary.js

@@ -7,7 +7,16 @@
 /** Collapse whitespace and clip to `max` chars (single line). */
 function oneLine(s, max = 80) {
     const t = String(s).replace(/\s+/g, ' ').trim();
-    return t.length > max ? t.slice(0, max - 1) + '…' : t;
+    if (t.length <= max)
+        return t;
+    // Never cut a surrogate PAIR in half: the log line is shown to the operator
+    // (and captured in the transcript), and a lone high surrogate at the end is
+    // a broken code point. Same rule as truncateToolResult / capReport.
+    let cut = max - 1;
+    const last = t.charCodeAt(cut - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        cut--;
+    return t.slice(0, cut) + '…';
 }
 function str(v) {
     return typeof v === 'string' ? v : '';

package/dist/tools.js

@@ -10,6 +10,17 @@ import { createExtraTools } from './extraTools.js';
 // user-facing. They must be in ENGLISH (like Claude Code / Codex). Only the
 // strings the OPERATOR sees (help, spinner, service messages) are localized —
 // those live in src/i18n.ts (CATALOG) and are picked by the locale setting.
+// Clip a long line without leaving a lone HIGH surrogate: the cut is in
+// UTF-16 units, so an emoji / astral CJK char on the boundary would lose its
+// low half and reach the model as a broken code point (same rule as
+// truncateToolResult / capReport / summarizeDiagnostics / bgTrim).
+function clipLine(l, max) {
+    let cut = max;
+    const last = l.charCodeAt(cut - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        cut--;
+    return l.slice(0, cut);
+}
 export function createTools(workdir, { undo, todos, readOnly = false, subagents = false, } = {}) {
     const root = path.resolve(workdir);
     const safe = (p) => safePath(root, p);
@@ -60,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. ' +
@@ -106,10 +118,17 @@ 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 ? l.slice(0, 2000) + ' …[line truncated]' : l;
+                const clip = (l) => l.length > 2000 ? clipLine(l, 2000) + ' …[line truncated]' : l;
                 if (!numbered)
                     return slice.map(clip).join('\n');
                 const width = String(start + slice.length).length;

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

@@ -77,31 +77,56 @@ export class UndoStore {
         const history = await this._readIndex();
         if (!history.length)
             return { ok: false, reason: 'empty' };
-        const record = history.pop();
-        if (!record)
-            return { ok: false, reason: 'empty' };
-        const { originalPath, existed, backupFile } = record;
-        try {
+        // Walk back from the newest record and SKIP a dead one (its .bak vanished,
+        // e.g. ~/.zames/undo was pruned or a crash left a record without the file).
+        // The old code popped the dead record, failed, and never rewrote the index —
+        // so every later /undo hit the same record again and the earlier backups
+        // stayed unreachable.
+        while (history.length) {
+            const record = history.pop();
+            if (!record)
+                break;
+            const { originalPath, existed, backupFile } = record;
+            let data = null;
             if (existed && backupFile) {
-                const data = await fs.readFile(backupFile);
-                await fs.writeFile(originalPath, data);
                 try {
-                    await fs.unlink(backupFile);
+                    data = await fs.readFile(backupFile);
+                }
+                catch (e) {
+                    if (e.code === 'ENOENT')
+                        continue;
+                    return { ok: false, reason: e.message };
                 }
-                catch { }
             }
-            else {
-                try {
-                    await fs.unlink(originalPath);
+            try {
+                if (data) {
+                    await fs.writeFile(originalPath, data);
+                    try {
+                        await fs.unlink(backupFile);
+                    }
+                    catch { }
                 }
-                catch { }
+                else {
+                    // existed === false: the agent CREATED the file, so undoing removes
+                    // it again. ENOENT is the expected case (it is already gone).
+                    try {
+                        await fs.unlink(originalPath);
+                    }
+                    catch { }
+                }
+                await this._writeIndex(history);
+                return { ok: true, record };
+            }
+            catch (e) {
+                // A real failure (permissions, a directory in place of the file): put
+                // the record back so a retry after fixing the cause still works.
+                history.push(record);
+                await this._writeIndex(history);
+                return { ok: false, reason: e.message };
             }
-            await this._writeIndex(history);
-            return { ok: true, record };
-        }
-        catch (e) {
-            return { ok: false, reason: e.message };
         }
+        await this._writeIndex(history);
+        return { ok: false, reason: 'empty' };
     }
     async list(count = 10) {
         const history = await this._readIndex();

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) => {
@@ -125,6 +132,49 @@ export function parseLegacyIpv4(host) {
     n += nums[nums.length - 1];
     return n >>> 0;
 }
+// Collapse an IPv6 literal to the canonical `a:b:c:d:e:f:g:h` hex form so the
+// prefix checks below see the SAME address whether it was written short
+// (`::1`, `::ffff:7f00:1`) or fully expanded (`0:0:0:0:0:0:0:1`,
+// `0:0:0:0:0:ffff:7f00:1`). A text-prefix match treated the expanded form as
+// PUBLIC, which let the SSRF guard reach loopback. Returns null for a non-IPv6
+// string or a malformed literal.
+function expandIpv6(ip) {
+    const s = ip.toLowerCase();
+    if (!s.includes(':'))
+        return null;
+    // An embedded dotted IPv4 tail (::ffff:127.0.0.1) is folded into two hex
+    // groups first, so the split below has a uniform shape.
+    const dotted = s.match(/^(.*:)(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    let body = s;
+    if (dotted) {
+        const [a, b, c, d] = dotted.slice(2).map(Number);
+        if ([a, b, c, d].some((n) => n > 255))
+            return null;
+        const hi = ((a << 8) | b).toString(16);
+        const lo = ((c << 8) | d).toString(16);
+        body = dotted[1] + hi + ':' + lo;
+    }
+    const halves = body.split('::');
+    if (halves.length > 2)
+        return null;
+    const head = halves[0] ? halves[0].split(':') : [];
+    const tail = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+    const groups = [];
+    for (const g of [...head, ...tail]) {
+        if (!/^[0-9a-f]{1,4}$/.test(g))
+            return null;
+        groups.push(g);
+    }
+    const missing = 8 - groups.length - (halves.length === 2 ? 0 : 0);
+    if (halves.length === 2) {
+        if (missing < 0)
+            return null;
+        return [...head, ...Array(missing).fill('0'), ...tail].map((g) => parseInt(g, 16));
+    }
+    if (groups.length !== 8)
+        return null;
+    return groups.map((g) => parseInt(g, 16));
+}
 export function isPrivateIp(ip) {
     const v4 = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
     if (v4) {
@@ -158,6 +208,36 @@ export function isPrivateIp(ip) {
         }
     }
     const low = ip.toLowerCase();
+    // Judge the EXPANDED form so `0:0:0:0:0:0:0:1` is treated exactly like
+    // `::1` (a text-prefix match called the expanded literal public).
+    const v6 = expandIpv6(ip);
+    if (v6) {
+        const allZero = v6.every((g) => g === 0);
+        const loopback = v6.slice(0, 7).every((g) => g === 0) && v6[7] === 1;
+        if (allZero || loopback)
+            return true;
+        const g0 = v6[0];
+        // fe80::/10 link-local, fec0::/10 deprecated site-local.
+        if ((g0 & 0xffc0) === 0xfe80 || (g0 & 0xffc0) === 0xfec0)
+            return true;
+        // fc00::/7 unique-local.
+        if ((g0 & 0xfe00) === 0xfc00)
+            return true;
+        // ff00::/8 multicast is not a public unicast destination either.
+        if ((g0 & 0xff00) === 0xff00)
+            return true;
+        // 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) {
+            return isPrivateIp((v6[6] >> 8) +
+                '.' +
+                (v6[6] & 0xff) +
+                '.' +
+                (v6[7] >> 8) +
+                '.' +
+                (v6[7] & 0xff));
+        }
+    }
     if (low === '::1' || low === '::')
         return true;
     // IPv6 link-local is fe80::/10, i.e. fe80..febf (the old `startsWith('fe80')`

package/package.json

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