zames_pro 2.79.0 → 2.80.0

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.80.0] - 2026-10-20
+
+### Fixed
+
+- **commands:** keep an unsupplied  position as written in a custom command
+- **subagent:** count a subagent run only once it actually starts
+- **attach:** do not cut an inlined @file inside a surrogate pair
+- **checkpoint:** a bare out-of-range rewind index no longer matches a stamp prefix
+- **git:** split a space-separated paths argument in GitAdd
+- **mcp:** keep an MCP tool result inside its size cap
+- **hooks:** never cut a hook denial or notice inside a surrogate pair
+- **sessions:** escape a literal underscore in the session file name
+
 ## [2.79.0] - 2026-10-19
 
 ### Fixed

package/dist/attach-refs.js

@@ -94,7 +94,15 @@ export async function inlineAtRefs(workdir, text) {
         let body = raw;
         let note = '';
         if (body.length > AT_REF_FILE_CAP) {
-            body = body.slice(0, AT_REF_FILE_CAP);
+            let cut = AT_REF_FILE_CAP;
+            // Never end the inlined block on a lone HIGH surrogate: the cut is in
+            // UTF-16 units, so an emoji / astral CJK char on the boundary would
+            // reach the model as a broken code point (same rule as
+            // truncateToolResult / capReport / cutHookText).
+            const last = body.charCodeAt(cut - 1);
+            if (last >= 0xd800 && last <= 0xdbff)
+                cut--;
+            body = body.slice(0, cut);
             note = NL + NL + '(truncated at ' + AT_REF_FILE_CAP + ' chars)';
         }
         total += body.length;

package/dist/checkpoint.js

@@ -50,10 +50,15 @@ export function pickRecord(records, selector) {
         return null;
     if (/^\d+$/.test(sel)) {
         const n = Number(sel);
-        // A small number is an index (1 = newest). An out-of-range number is
-        // still tried as a stamp prefix below, so `/rewind 1730000` works.
+        // A small number is an index (1 = newest).
         if (n >= 1 && n <= records.length)
             return records[n - 1];
+        // A stamp is epoch-ms (~13 digits), but older files and tests may hold
+        // a SHORT one, so the prefix form stays. What must NOT happen is a bare
+        // out-of-range INDEX matching a stamp by its first digit (`/rewind 9`
+        // with 5 checkpoints): the prefix form therefore needs TWO digits.
+        if (sel.length < 2)
+            return null;
     }
     return records.find((r) => String(r.stamp).startsWith(sel)) || null;
 }

package/dist/commands.js

@@ -773,7 +773,11 @@ function replaceDollarTokens(s, parts, names) {
             continue;
         }
         if (isAllDigits(tok)) {
-            res += parts[Number(tok) - 1] ?? '';
+            const idx = Number(tok) - 1;
+            // A position that was NOT supplied stays as written: `$100` in prose
+            // is a PRICE, not "position 100", and replacing it with an empty
+            // string silently deleted the number from the prompt.
+            res += idx >= 0 && idx < parts.length ? parts[idx] : '$' + tok;
         }
         else {
             const idx = names.indexOf(tok);

package/dist/gitTools.js

@@ -44,6 +44,39 @@ export function runGitArgs(args, cwd, timeout = 15_000) {
         });
     });
 }
+// Split a `paths` argument into individual pathspecs. The parameter is
+// declared as a STRING, so models send "a.txt b.txt" or a quoted path with a
+// space ("my file.txt"); git needs each path as its OWN argument.
+export function splitPaths(input) {
+    const out = [];
+    const s = String(input || '');
+    let cur = '';
+    let quote = null;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\n') {
+            if (cur)
+                out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
 export async function getGitContext(workdir) {
     const probe = await runGitArgs(['rev-parse', '--is-inside-work-tree'], workdir, 5000);
     if (probe.trim() !== 'true')
@@ -215,16 +248,27 @@ export function createGitTools(workdir) {
                 if (err)
                     return err;
                 if (paths && String(paths).trim()) {
-                    const list = (Array.isArray(paths) ? paths : [paths])
+                    // `paths` is declared as a STRING, so the model sends
+                    // "a.txt b.txt". Passing it as ONE pathspec made git answer
+                    // `did not match any files` and staged nothing. Split on
+                    // whitespace, honour quotes (a path may contain a space), and
+                    // keep the array form working.
+                    const list = (Array.isArray(paths) ? paths : splitPaths(String(paths)))
                         .map((v) => String(v).trim())
                         .filter(Boolean);
                     for (const p of list) {
                         if (p.startsWith('-'))
                             return `Error: invalid path: ${p}`;
                     }
-                    return runGitArgs(['add', '--', ...list], workdir, 20_000);
+                    const staged = await runGitArgs(['add', '--', ...list], workdir, 20_000);
+                    // A successful `git add` prints NOTHING; the shared runner then
+                    // answers the internal sentinel, which reads as a failure.
+                    return staged.trim() === NO_OUTPUT_SENTINEL
+                        ? 'Staged: ' + list.join(' ')
+                        : staged;
                 }
-                return runGitArgs(['add', '-A'], workdir, 20_000);
+                const all = await runGitArgs(['add', '-A'], workdir, 20_000);
+                return all.trim() === NO_OUTPUT_SENTINEL ? 'Staged all changes.' : all;
             },
         },
         {

package/dist/hooks.js

@@ -18,6 +18,19 @@ 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;
+// Cut a hook string by UTF-16 units WITHOUT leaving a lone HIGH surrogate at
+// the end: the text becomes a tool result or a chat notice, and a broken code
+// point there is the same bug truncated elsewhere (same rule as
+// truncateToolResult / capReport / summarizeDiagnostics).
+function cutHookText(s, max) {
+    if (s.length <= max)
+        return s;
+    let cut = Math.max(0, max);
+    const last = s.charCodeAt(cut - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        cut--;
+    return s.slice(0, cut);
+}
 export function hooksConfigPath(workdir) {
     return path.join(workdir, '.zames', 'hooks.json');
 }
@@ -150,7 +163,7 @@ export async function runPreToolUse(hooks, tool, args, workdir) {
             const reason = (r.stderr || r.stdout).trim();
             // The denial text becomes a TOOL RESULT the model reads: a hook that
             // dumps a log must not flood the context with one call.
-            const capped = reason.slice(0, HOOK_DENIAL_CAP);
+            const capped = cutHookText(reason, HOOK_DENIAL_CAP);
             const suffix = reason.length > HOOK_DENIAL_CAP
                 ? '\n… [denial truncated: ' +
                     (reason.length - HOOK_DENIAL_CAP) +
@@ -198,14 +211,14 @@ async function runEventHooks(hooks, event, workdir, tool, args, result) {
         // hundreds of KB and flood the context.
         if (total >= HOOK_OUTPUT_CAP)
             break;
-        const piece = out.slice(0, HOOK_OUTPUT_CAP - total);
+        const piece = cutHookText(out, HOOK_OUTPUT_CAP - total);
         total += piece.length;
         parts.push(piece);
     }
     const joined = parts.join(String.fromCharCode(10));
     if (joined.length <= HOOK_OUTPUT_CAP)
         return joined;
-    return (joined.slice(0, HOOK_OUTPUT_CAP) +
+    return (cutHookText(joined, HOOK_OUTPUT_CAP) +
         String.fromCharCode(10) +
         '… [hook output truncated]');
 }

package/dist/mcp.js

@@ -183,7 +183,14 @@ export function truncateMcpResult(s, limit = MCP_RESULT_LIMIT) {
     const str = String(s);
     if (str.length <= limit)
         return str;
-    let head = str.slice(0, limit);
+    // The MARKER is part of the result, so the head must leave room for it:
+    // appending it to a limit-long head produced a result WIDER than the cap
+    // (the cap exists to bound the context a single MCP call can consume).
+    // Reserve the WORST-CASE marker (a 10-digit count), so no result can
+    // exceed the cap whatever the omitted length turns out to be.
+    const MARKER = '\n[...truncated 9999999999 chars]';
+    const budget = Math.max(0, limit - MARKER.length);
+    let head = str.slice(0, budget);
     // Never leave a lone HIGH surrogate at the cut: an emoji / astral CJK char
     // sits on two UTF-16 units, and cutting between them hands the model a
     // broken code point (same rule as truncateToolResult / capReport).
@@ -194,7 +201,7 @@ export function truncateMcpResult(s, limit = MCP_RESULT_LIMIT) {
     }
     // Prefer a line boundary so a cut does not split a line in half.
     const nl = head.lastIndexOf(String.fromCharCode(10));
-    const cut = nl > limit * 0.5 ? head.slice(0, nl + 1) : head;
+    const cut = nl > budget * 0.5 ? head.slice(0, nl + 1) : head;
     const omitted = str.length - cut.length;
     return cut + `\n[...truncated ${omitted} chars]`;
 }

package/dist/sessions.js

@@ -55,7 +55,10 @@ function safeName(id) {
     const s = String(id);
     let out = '';
     for (const ch of s) {
-        if (/[a-zA-Z0-9.-]/.test(ch))
+        // `_` ITSELF is the escape prefix: leaving a literal underscore in
+        // place made the encoding ambiguous (`a/b` -> `a_2fb` collided with the
+        // real id `a_2fb`), so one session silently overwrote the other.
+        if (/[a-zA-Z0-9.-]/.test(ch) && ch !== '_')
             out += ch;
         else
             out += '_' + ch.codePointAt(0).toString(16).padStart(2, '0');

package/dist/subagent.js

@@ -76,7 +76,6 @@ export function createSubagentRunner(opts) {
                     ' per task). Do the remaining work yourself with the other tools.',
             };
         }
-        used++;
         // Resolve the parent chat id BEFORE anything else. The runner restores the
         // parent chat in its finally block, and that restore is what keeps the
         // subagent's isolated context from swallowing the parent's turn. If the id
@@ -98,6 +97,10 @@ export function createSubagentRunner(opts) {
                     'would be lost). Do the work yourself with the other tools.',
             };
         }
+        // Count the run only NOW: every early exit above (budget, unknown
+        // parent chat id) returned BEFORE anything ran, and charging those
+        // attempts burned the whole budget on runs that never started.
+        used++;
         const subTools = buildTools(req.type === 'explore');
         const taskText = subagentPersona(req.type) + '\n\n--- SUB-TASK ---\n' + req.prompt;
         // Save the parent's send hooks: the nested loop OVERWRITES them on

package/package.json

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