z0gcode 0.3.1 → 0.3.2

package/README.md

@@ -90,7 +90,7 @@ z0g serve --mcp                                          # expose z0gcode's 0G t
 - **Project context**: `AGENTS.md` (and `.z0g/context.md`) are auto-loaded into the agent's system prompt on every run, so it follows your conventions and uses your real build/test/run commands. `z0g init` (or `/init`) analyzes the repo and writes an accurate `AGENTS.md` for you.
 - **Checkpoints and undo**: every file edit is logged with its before/after content per turn, so `z0g undo` (or `/undo`) reverts the last turn's changes (restoring files, deleting ones it created); `z0g checkpoints` lists what you can step back through.
 - **Custom commands and hooks**: drop `.z0g/commands/<name>.md` to add a `/<name>` slash command (the file is a prompt template; `$ARGUMENTS` is substituted, optional `description:` frontmatter, Tab-completed and listed by `/commands`). Define lifecycle hooks in `.z0g/hooks.json` (`preRun` / `postRun` shell commands, e.g. run your formatter or tests after each turn); hooks run shell, so they only fire with `--auto`.
-- Reliability on a decentralized backend: app-level multi-model fallback, retry and backoff, tool-JSON repair, a loop breaker (stops on repeated identical calls, or the same tool result with no progress, so it hands control back instead of spinning), and model escalation (when a tool fails repeatedly it moves to a stronger fallback for the rest of the turn; on by default after 3 failures, toggle with `/escalate on|off` or `--no-escalate`).
+- Reliability on a decentralized backend: app-level multi-model fallback, retry and backoff, tool-JSON repair, a loop breaker (on repeated identical calls, or the same tool result with no progress, it first escalates to a stronger model to try to get unstuck and only then hands control back, instead of spinning), and model escalation (when a tool fails repeatedly it moves to a stronger fallback for the rest of the turn; on by default after 3 failures, toggle with `/escalate on|off` or `--no-escalate`).
 - **Parallel subagents**: `spawn_subagents` fans out independent, read-only subtasks (review many files, research, audit, map a codebase) as isolated agents running in parallel, capped by `ZOG_MAX_PARALLEL`. The parent synthesizes the results and each subagent's transcript is saved. With 0G's cheap inference, fanning out to many agents costs cents: massively parallel agents at 0G prices. On by default; toggle with `/subagents on|off` or `--no-subagents`.
 - **Parallel write subagents**: with `--auto` in a git repo, `spawn_write_subagents` fans out subtasks that WRITE code, each in its own isolated **git worktree**, then merges every diff back into the working tree. Disjoint file sets merge automatically; overlapping edits are reported and skipped (never half-applied), and the merged changes are checkpointed so `z0g undo` reverts them. Verified end-to-end on 0G.
 

package/bin/z0g.mjs

@@ -1045,7 +1045,7 @@ async function main() {
   if (flags.version) {
     let v = "";
     try { v = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version; } catch {}
-    console.log("z0gcode " + (v || "0.3.1"));
+    console.log("z0gcode " + (v || "0.3.2"));
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z0gcode",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A terminal coding agent whose brain runs on 0G Compute: private, verifiable AI with on-chain provenance.",
   "type": "module",
   "bin": {

package/src/agent.mjs

@@ -92,6 +92,7 @@ export async function runAgent({ client, task, cwd, sessionDir, allowBash, prefe
 
   const recent = []; // circuit breaker on repeated identical tool calls
   const results = []; // no-progress breaker: repeated identical tool RESULTS
+  let loopEscalated = false; // escalate once on a spin before giving up
   const failCounts = {}; // per-tool failure counter, drives model escalation
   const escalateOn = preferredEscalate !== undefined ? preferredEscalate : CONFIG.escalate;
   const escalateAfter = CONFIG.escalateAfter;
@@ -301,7 +302,15 @@ export async function runAgent({ client, task, cwd, sessionDir, allowBash, prefe
       const rkey = `${name}|${res.summary || ""}|${String(res.content ?? "").slice(0, 300)}`;
       results.push(rkey);
       if (results.length > 8) results.shift();
-      if (results.filter((k) => k === rkey).length >= 3) stuck = true;
+      const repeat = results.filter((k) => k === rkey).length;
+      // Spinning on the same result: it is usually a model limitation, so first
+      // escalate to a stronger model (and stay on it) to give it a chance to get
+      // unstuck; only give up and hand control back if it still makes no progress.
+      if (repeat === 2 && escalateOn && !loopEscalated && activeModel === models[0]) {
+        escalate = true; loopEscalated = true;
+        if (!q) ui.info("spinning on the same result: trying a stronger model");
+      }
+      if (repeat >= (escalateOn ? 4 : 3)) stuck = true;
     }
 
     if (stuck) {