zames_pro 2.75.1 → 2.75.2

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.75.2] - 2026-10-15
+
+### Changed
+
+- batch read-only tool calls and skip redundant checkpoints
+
 ## [2.75.1] - 2026-10-15
 
 ### Added

package/dist/agent-loop.js

@@ -180,6 +180,15 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // block after the tool loop).
     let malformedRetries = 0;
     const MAX_MALFORMED_RETRIES = 3;
+    // Tool-result caps for the message fed back to the model. A single result
+    // gets a generous cap; in a BATCH each item is capped and the ASSEMBLED
+    // message is capped again, so a big batch cannot exceed what the chat input
+    // accepts (a failed paste loses the whole turn). The caps are explicit:
+    // truncateToolResult() appends `[...truncated N chars]` so the model knows
+    // it is looking at a partial output.
+    const TOOL_RESULT_LIMIT = 24_000;
+    const BATCH_ITEM_LIMIT = 16_000;
+    const BATCH_TOTAL_LIMIT = 120_000;
     let stallRetries = 0;
     const MAX_STALL_RETRIES = 5;
     // SINGLE shared budget for "the answer is not a recognized tool call".
@@ -752,6 +761,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // and no call matches an `ask` permission rule (a concurrent operator
         // prompt would race). Anything else keeps the strict sequential loop, so
         // mutating side effects never reorder.
+        //
+        // MUTATING tools (Write/Edit/MultiEdit) are deliberately NOT here even
+        // though writes to different files are logically independent: (a)
+        // UndoStore.backup() does a read-modify-write of ONE shared index file, so
+        // two concurrent backups race and lose a record; (b) PostToolUse hooks and
+        // diagnostics must run in a defined order. A batch of mutating calls still
+        // costs only ONE round-trip (the sequential loop below runs them all for
+        // the same answer), so nothing is lost by keeping them sequential.
         const PARALLEL_SAFE = new Set(['Read', 'Glob', 'Grep', 'LS', 'WebFetch']);
         const readOnlyBatch = callsToRun.length > 1 &&
             !(hookConfig.PreToolUse && hookConfig.PreToolUse.length) &&
@@ -1064,15 +1081,23 @@ ${diag}`;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
-            message = `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, 12_000)}`;
+            message = `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, TOOL_RESULT_LIMIT)}`;
         }
         else {
             message = results
                 .map((r) => {
                 const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
-                return `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, 8000)}`;
+                return `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, BATCH_ITEM_LIMIT)}`;
             })
                 .join('\n\n');
+            // A large batch (e.g. 8 Reads) could still add up past what the chat
+            // input accepts; a too-long message fails to paste (ds.input_partial) and
+            // the whole turn is lost. Cap the ASSEMBLED message as a safety net,
+            // keeping the per-item truncation markers (the model still sees WHAT was
+            // dropped, just a bit more of it).
+            if (message.length > BATCH_TOTAL_LIMIT) {
+                message = truncateToolResult(message, BATCH_TOTAL_LIMIT);
+            }
         }
         // Append the argument-error nudge (set inside the batch loop) now that
         // `message` has been rebuilt from `results`. Cleared so it fires once per

package/dist/browser.js

@@ -1895,8 +1895,11 @@ export class DeepSeekBrowser {
             }
             // Reasoning-mode pause during the THINK phase: click Continue so the
             // generation resumes (the button appears before any RESPONSE text, so
-            // the start-wait would otherwise spin until the deadline).
-            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+            // the start-wait would otherwise spin until the deadline). Probing
+            // PROACTIVELY is meaningful only with the reasoning toggle ON.
+            if (this.autoContinue &&
+                this.deepThinking &&
+                (await this._clickContinueIfVisible())) {
                 this._askDebug('CLICKED Continue (start-loop)');
             }
             const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
@@ -1935,8 +1938,12 @@ export class DeepSeekBrowser {
             const notGenerating = !(await this._isGenerating());
             const differs = !!cur && normText(cur) !== normText(beforeText);
             // Do NOT accept a "settled" answer while Continue is on screen — that
-            // is a paused generation, not a finished one.
-            const paused = this.autoContinue && (await this._continueButtonVisible());
+            // is a paused generation, not a finished one. The paused check only
+            // applies with the reasoning toggle ON (the THINK-phase pause); without
+            // it a stable answer is a genuinely finished one.
+            const paused = this.autoContinue &&
+                this.deepThinking &&
+                (await this._continueButtonVisible());
             if (differs && cur === lastStartCur && notGenerating && !paused) {
                 settledTicks++;
                 if (settledTicks >= 2) {
@@ -2095,8 +2102,15 @@ export class DeepSeekBrowser {
             }
             // Reasoning-mode pause: DeepSeek caps the THINK phase and shows a
             // Continue button; the model does not resume by itself. Click it so the
-            // answer keeps flowing instead of waiting for the operator.
-            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+            // answer keeps flowing instead of waiting for the operator. Only probe
+            // PROACTIVELY when the reasoning (Deep thinking) toggle is ON: the
+            // THINK-phase pause does not occur without it, so an idle probe on every
+            // tick is a wasted evaluate. The truncated / finished-without-answer
+            // branches above stay unconditional — those are server faults, not a
+            // reasoning pause, and occur with the toggle off too.
+            if (this.autoContinue &&
+                this.deepThinking &&
+                (await this._clickContinueIfVisible())) {
                 this._askDebug('CLICKED Continue (finish-loop)');
                 continue;
             }
@@ -2156,8 +2170,11 @@ export class DeepSeekBrowser {
                     // A PAUSED generation also looks "stable" (the text stops changing
                     // while Continue is on screen), so the old check returned the
                     // partial answer here — the "agent stopped with a Continue button"
-                    // symptom. Click Continue and keep waiting instead.
-                    if (this.autoContinue && (await this._continueButtonVisible())) {
+                    // symptom. Click Continue and keep waiting instead. Only relevant
+                    // with the reasoning toggle ON (the THINK-phase pause).
+                    if (this.autoContinue &&
+                        this.deepThinking &&
+                        (await this._continueButtonVisible())) {
                         if (await this._clickContinueIfVisible()) {
                             this._askDebug('CLICKED Continue (before early return)');
                         }
@@ -2205,7 +2222,8 @@ export class DeepSeekBrowser {
         if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
             // If Continue is STILL on screen, the turn is paused, not finished:
             // click once more and report what we have rather than silently stopping.
-            if (this.autoContinue)
+            // Only with the reasoning toggle ON (the THINK-phase pause).
+            if (this.autoContinue && this.deepThinking)
                 await this._clickContinueIfVisible();
             this._askDebug('RETURN last len=' + last.length);
             return last;

package/dist/checkpoint.js

@@ -69,6 +69,19 @@ function runTar(args, cwd, timeout = 60_000) {
         });
     });
 }
+// Git fingerprint of a working tree: HEAD plus the porcelain status. Two
+// snapshots with the same fingerprint hold the same TRACKED state, so a
+// second checkpoint would be a duplicate. Returns null for a non-git dir (or
+// when git is unavailable) — then the caller always snapshots (no debounce).
+function workdirFingerprint(workdir) {
+    return new Promise((resolve) => {
+        execFile('git', ['-C', workdir, 'status', '--porcelain=v1', '--branch'], { timeout: 10_000, maxBuffer: 1024 * 1024, windowsHide: true }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            resolve(String(stdout || '').trim() || 'clean');
+        });
+    });
+}
 async function copyTree(from, to) {
     await fs.mkdir(to, { recursive: true });
     const entries = await fs.readdir(from, { withFileTypes: true });
@@ -116,10 +129,34 @@ export class CheckpointStore {
      * unreadable dir or a timeout yields null, never a thrown error — a failed
      * checkpoint must not abort the task it was meant to protect.
      */
-    async create(workdir, label) {
+    async create(workdir, label, 
+    /** When false, always create a new archive (skip the fingerprint dedupe). */
+    allowDedupe = true) {
         if (!this.enabled)
             return null;
         await this._ensure();
+        // Debounce: a checkpoint is taken before EVERY task, and consecutive
+        // tasks in one queue often start with an IDENTICAL tracked state (the
+        // previous task made no commit and no tracked edit that survived).
+        // Re-taring the whole tree then only burns time. If the last record for
+        // this workdir carries the SAME git fingerprint, reuse it instead of
+        // snapshotting again. Non-git dirs get a null fingerprint and are always
+        // snapshotted (we cannot cheaply prove the tree is unchanged).
+        const fingerprint = allowDedupe ? await workdirFingerprint(workdir) : null;
+        if (fingerprint) {
+            const history = await this._readIndex();
+            const last = [...history]
+                .reverse()
+                .find((r) => r.workdir === workdir && r.fingerprint);
+            if (last &&
+                last.fingerprint === fingerprint &&
+                (await fs
+                    .access(last.file)
+                    .then(() => true)
+                    .catch(() => false))) {
+                return last;
+            }
+        }
         const stamp = Date.now();
         // Two checkpoints in the SAME millisecond would share `${stamp}.tgz` and
         // the second would overwrite the first (losing a snapshot). Add a random
@@ -134,6 +171,8 @@ export class CheckpointStore {
         const record = { stamp, file, workdir };
         if (label)
             record.label = label;
+        if (fingerprint)
+            record.fingerprint = fingerprint;
         const history = await this._readIndex();
         history.push(record);
         const kept = rotateRecords(history, this.maxBackups);
@@ -171,7 +210,7 @@ export class CheckpointStore {
         if (!exists)
             return { ok: false, reason: 'archive_missing' };
         // Backup the CURRENT tree before touching it.
-        const backup = await this.create(record.workdir, 'pre-rewind');
+        const backup = await this.create(record.workdir, 'pre-rewind', false);
         // Extract to a temp dir FIRST; only a successful extract may touch workdir
         // (otherwise a bad archive would wipe the tree).
         const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'zames-rewind-'));

package/dist/system-prompt.js

@@ -234,6 +234,33 @@ Prefer the most specific tool; a wrong choice wastes a turn:
 - Reading a file whose path you already know -> Read, not Bash cat.
 - A broad search/exploration that would flood this chat -> the Task tool
   (a subagent in its own chat) if it is available, then work from its report.
+
+## Batch independent calls (IMPORTANT: saves round-trips)
+
+Every separate turn costs a full send + throttle pause, so DO NOT dribble
+calls out one at a time when you already know several are needed. When the
+next step requires reading, searching or writing SEVERAL known targets, emit
+ONE JSON array with all of them in a single answer:
+
+[{"tool": "Read", "args": {"path": "a.ts"}},
+ {"tool": "Read", "args": {"path": "b.ts"}},
+ {"tool": "Grep", "args": {"pattern": "foo", "include": "*.ts"}}]
+
+Rules for a batch:
+- BATCH only INDEPENDENT calls: no call may depend on another call's result
+  (do not batch a Read and an Edit of the same file, and never batch two
+  writes to the SAME path).
+- Read-only calls (Read, Glob, Grep, LS, WebFetch) run CONCURRENTLY, so a
+  batch of them is several times faster than the same calls one by one.
+- Writing to SEVERAL DIFFERENT files can be batched too (e.g. three Write
+  calls to three different new paths, or Edits to different files). Mutating
+  calls in a batch run in order, so a batch still saves the extra round-trips
+  even though the writes themselves are serialized.
+- If the next step depends on what a call RETURNS, that call must be alone
+  (or be the last one in the batch).
+- Typical wins: read all the files a task mentions at once; grep for all the
+  symbols you need at once; after planning a multi-file change, write all the
+  files you can write independently at once.
 ${subagentSection}
 ## MCP tools
 

package/package.json

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