open-agents-ai 0.187.467 → 0.187.469

package/dist/index.js

@@ -517859,6 +517859,15 @@ var init_agenticRunner = __esm({
       // a phase's worth of work without recording progress — and on the next
       // turn will replay the same plan. Surface a nudge before that happens.
       _writesSinceLastTodoWrite = 0;
+      // REG-12: Progress gate (root-cause enforcement). When ≥6 file writes
+      // have happened without a todo_write call, this latch flips ON. While
+      // the latch is on, every tool call EXCEPT todo_write/todo_read/
+      // task_complete/ask_user is intercepted with a synthetic '[PROGRESS GATE]'
+      // result that forces the agent to update its plan before continuing.
+      // Released when todo_write fires successfully. Without this, the agent
+      // can re-emit the same plan a second time (plan-replay) and execute
+      // duplicate work because PROGRESS NUDGE alone is informational.
+      _progressGateActive = false;
       // REG-5: Rolling buffer of recent tool failures with their error output.
       // Surfaced before every LLM call so the agent can't ignore "I just ran this
       // and it errored". Detects same-fingerprint failure repetition and escalates
@@ -518592,41 +518601,98 @@ ${body}`;
         if (!output || typeof output !== "string")
           return null;
         const text = output;
-        const tail = text.slice(-3e3);
-        if (/\bTS\d{3,5}\b.*?: /m.test(tail) && /\berror\s+TS\d{3,5}\b/i.test(tail)) {
+        const tail = text.slice(-4e3);
+        if (/\berror\s+TS\d{3,5}\b/i.test(tail)) {
           const m2 = tail.match(/error\s+TS\d{3,5}[^\n]{0,200}/i);
-          return `TypeScript build error detected: ${(m2?.[0] ?? "").slice(0, 200)}`;
+          return `Compile error: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
-        if (/\b(Failed to compile|Compilation failed|Build failed)\b/i.test(tail)) {
-          const m2 = tail.match(/(Failed to compile|Compilation failed|Build failed)[^\n]{0,300}/i);
-          return `Build failed: ${(m2?.[0] ?? "").slice(0, 200)}`;
+        if (/\berror\[E\d+\]/i.test(tail)) {
+          const m2 = tail.match(/error\[E\d+\][^\n]{0,200}/i);
+          return `Compile error: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
-        if (/\bError:\s+Build failed\b/i.test(tail)) {
-          return "Next.js build failed (webpack/rspack errors)";
+        if (/\berror\s+CS\d{3,5}\b/i.test(tail)) {
+          const m2 = tail.match(/error\s+CS\d{3,5}[^\n]{0,200}/i);
+          return `Compile error: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
-        if (/\b\d+\s+errors? found\b/i.test(tail) && /\b(error|failed)\b/i.test(tail)) {
-          const m2 = tail.match(/\d+\s+errors? found[^\n]{0,200}/i);
-          return `Build reported errors: ${(m2?.[0] ?? "").slice(0, 200)}`;
+        if (/(^|\n)\S+:\d+:\d+:\s+error:/i.test(tail)) {
+          const m2 = tail.match(/\S+:\d+:\d+:\s+error:[^\n]{0,200}/i);
+          return `Compile error: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\bundefined\s+reference\s+to\b|\bld:\s+error:/i.test(tail)) {
+          const m2 = tail.match(/(undefined\s+reference\s+to|ld:\s+error:)[^\n]{0,200}/i);
+          return `Linker error: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\b(Failed to compile|Compilation failed|Build failed|BUILD\s+FAIL(ED|URE))\b/i.test(tail)) {
+          const m2 = tail.match(/(Failed to compile|Compilation failed|Build failed|BUILD\s+FAIL(?:ED|URE))[^\n]{0,300}/i);
+          return `Build failed: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\b\d+\s+errors?\s+(found|generated)\b/i.test(tail)) {
+          const m2 = tail.match(/\d+\s+errors?\s+(?:found|generated)[^\n]{0,200}/i);
+          return `Build reported errors: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
         if (/\bnpm\s+ERR!|\bnpm error code\b/i.test(tail)) {
           const m2 = tail.match(/(npm\s+ERR!|npm error code)[^\n]{0,300}/i);
-          return `npm error: ${(m2?.[0] ?? "").slice(0, 200)}`;
+          return `Package install error: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\bERROR:\s+Could not (install|find|build)\b/i.test(tail)) {
+          const m2 = tail.match(/ERROR:\s+Could not[^\n]{0,200}/i);
+          return `Package install error: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\b(E:\s+(Unable to|Could not)|apt-get:\s+error|dnf:\s+(?:Error|Failed)|pacman:\s+error)/i.test(tail)) {
+          const m2 = tail.match(/(E:\s+|apt-get:\s+error|dnf:\s+|pacman:\s+error)[^\n]{0,200}/i);
+          return `System package error: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\bTests?:\s+\d+\s+failed\b/i.test(tail)) {
+          const m2 = tail.match(/Tests?:[^\n]{0,200}/i);
+          return `Test failures: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/^FAILED\s+\S+::/m.test(tail) || /=+\s*\d+\s+failed/i.test(tail)) {
+          const m2 = tail.match(/(FAILED\s+\S+|=+\s*\d+\s+failed)[^\n]{0,200}/i);
+          return `Test failures: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\b\d+\s+failing\b/i.test(tail) && /\bpassing\b/i.test(tail)) {
+          const m2 = tail.match(/\d+\s+failing[^\n]{0,200}/i);
+          return `Test failures: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/^---\s+FAIL:/m.test(tail) || /^FAIL\t\S+/m.test(tail)) {
+          const m2 = tail.match(/(---\s+FAIL:[^\n]{0,200}|FAIL\t\S+[^\n]{0,200})/i);
+          return `Test failures: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/test\s+result:\s+FAILED/i.test(tail)) {
+          const m2 = tail.match(/test\s+result:\s+FAILED[^\n]{0,200}/i);
+          return `Test failures: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\b\d+\s+failed\s+(of|out\s+of)\s+\d+\b/i.test(tail)) {
+          const m2 = tail.match(/\d+\s+failed\s+(?:of|out\s+of)\s+\d+[^\n]{0,200}/i);
+          return `Test failures: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/^Traceback \(most recent call last\):/m.test(tail) && /\w+(?:Error|Exception):\s/.test(tail)) {
+          const m2 = tail.match(/\w+(?:Error|Exception):[^\n]{0,200}/);
+          return `Runtime exception: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
-        if (/\bTests:\s+\d+\s+failed\b/i.test(tail) || /\b\d+\s+failed\b.*\bof\s+\d+\b/i.test(tail)) {
-          const m2 = tail.match(/Tests:[^\n]{0,200}|\d+\s+failed[^\n]{0,200}/i);
-          return `Test failures detected: ${(m2?.[0] ?? "").slice(0, 200)}`;
+        if (/\b(UnhandledPromiseRejection|throw\s+new\s+\w+|Uncaught\s+\w+Error)\b/i.test(tail)) {
+          const m2 = tail.match(/(UnhandledPromiseRejection|throw\s+new\s+\w+|Uncaught[^\n]{0,200})/i);
+          return `Runtime exception: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
-        if (/^Traceback \(most recent call last\):/m.test(tail) && /\bError:|Exception:/m.test(tail)) {
-          const m2 = tail.match(/(\w+(?:Error|Exception)):[^\n]{0,200}/);
-          return `Python exception: ${(m2?.[0] ?? "").slice(0, 200)}`;
+        if (/\b(Exception\s+in\s+thread|java\.\w+(?:Error|Exception):)/i.test(tail)) {
+          const m2 = tail.match(/(Exception\s+in\s+thread[^\n]{0,200}|java\.\w+(?:Error|Exception):[^\n]{0,200})/i);
+          return `Runtime exception: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
-        if (/\berror\[E\d+\]:/i.test(tail) || /\b(\.\/[\w./-]+):\d+:\d+:\s+error:/i.test(tail)) {
-          const m2 = tail.match(/error\[E\d+\][^\n]{0,200}|\.\/[\w./-]+:\d+:\d+:\s+error:[^\n]{0,200}/i);
-          return `Compiler error: ${(m2?.[0] ?? "").slice(0, 200)}`;
+        if (/^[\w./:-]+:\d+:in\s+`[^']*':\s+/m.test(tail) && /\b\w+Error\b/.test(tail)) {
+          const m2 = tail.match(/\b\w+Error[^\n]{0,200}/);
+          return `Runtime exception: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\bthread\s+'[^']*'\s+panicked\s+at/i.test(tail)) {
+          const m2 = tail.match(/thread\s+'[^']*'\s+panicked\s+at[^\n]{0,200}/i);
+          return `Runtime panic: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
         if (/^(fatal|FATAL|panic):\s/m.test(tail)) {
           const m2 = tail.match(/^(fatal|FATAL|panic):\s[^\n]{0,200}/m);
-          return `Fatal error: ${(m2?.[0] ?? "").slice(0, 200)}`;
+          return `Fatal error: ${(m2?.[0] ?? "").slice(0, 240)}`;
+        }
+        if (/\b(Segmentation\s+fault|core\s+dumped|Abort(?:ed)?\s+\(core dumped\)|Killed)\b/i.test(tail)) {
+          const m2 = tail.match(/(Segmentation\s+fault|core\s+dumped|Abort(?:ed)?\s+\(core dumped\)|Killed)[^\n]{0,80}/i);
+          return `Process terminated abnormally: ${(m2?.[0] ?? "").slice(0, 240)}`;
         }
         return null;
       }
@@ -518683,6 +518749,7 @@ ${body}`;
         if (/(^|[^&\d])(>|>>)\s*\S/.test(cmd))
           return false;
         const MUTATE_BINS = [
+          // POSIX file/process mutators
           "rm",
           "mv",
           "cp",
@@ -518690,56 +518757,158 @@ ${body}`;
           "rmdir",
           "chmod",
           "chown",
+          "chgrp",
           "touch",
           "tee",
           "dd",
           "truncate",
           "ln",
+          "install",
           "kill",
           "pkill",
           "killall",
           "reboot",
           "shutdown",
+          "halt",
+          "poweroff",
           "fakeroot",
           "sudo",
+          "doas",
           "nohup",
           "setsid",
+          "su",
+          // Build orchestrators (always trigger compile/test side-effects)
           "make",
+          "gmake",
+          "ninja",
           "gradle",
+          "gradlew",
           "mvn",
+          "mvnw",
+          "ant",
+          "bazel",
+          "buck",
+          "buck2",
+          "cmake",
+          "meson",
+          "scons",
+          "rake",
+          "leiningen",
+          "lein",
+          "sbt",
+          "stack",
+          // Configuration-management / orchestration
           "ansible",
-          "systemd-run"
+          "ansible-playbook",
+          "puppet",
+          "chef-client",
+          "salt",
+          "salt-call",
+          "systemd-run",
+          "systemd-analyze",
+          // System package managers
+          "apt",
+          "apt-get",
+          "yum",
+          "dnf",
+          "rpm",
+          "pacman",
+          "zypper",
+          "emerge",
+          "snap",
+          "flatpak",
+          "brew",
+          "port",
+          "pkg",
+          "apk",
+          "choco",
+          "scoop",
+          "winget",
+          // Helm / k8s-flavored
+          "helm",
+          "helmfile",
+          "kustomize"
         ];
         const mutateBinsRe = new RegExp(`\\b(${MUTATE_BINS.join("|")})\\b`, "i");
         if (mutateBinsRe.test(cmd))
           return false;
         if (/\bsed\s+(-i|--in-place)\b/.test(cmd))
           return false;
-        if (/\bsystemctl\s+(?!status\b|show\b|is-)/i.test(cmd))
+        if (/\bsystemctl\s+(?!status\b|show\b|is-|cat\b|list-|get-)/i.test(cmd))
           return false;
         if (/\bservice\s+\S+\s+(?!status\b)/i.test(cmd))
           return false;
         if (/\bcrontab\s+-(e|d|r)\b/.test(cmd))
           return false;
-        if (/\bnpm\s+(install|uninstall|update|run|test|exec|publish|init|link|unlink|version|cache\s+clean|ci|audit\s+fix)\b/i.test(cmd))
-          return false;
-        if (/\bpnpm\s+(install|update|add|remove|run|test|exec|publish|init|link|unlink|version)\b/i.test(cmd))
+        if (/\bnpm\s+(install|i\b|uninstall|un\b|update|up\b|run\s|test\b|exec|publish|init|link|unlink|version|cache\s+clean|ci\b|audit\s+fix|prune|rebuild|adduser|login|logout|deprecate)\b/i.test(cmd))
           return false;
-        if (/\byarn\s+(install|add|remove|upgrade|run|test|exec|publish|init|link|unlink|version)\b/i.test(cmd))
+        if (/\bpnpm\s+(install|i\b|update|up\b|add|remove|rm\b|run\s|test\b|exec|publish|init|link|unlink|version|prune|rebuild)\b/i.test(cmd))
           return false;
-        if (/\bpip\s+(install|uninstall|wheel)\b/i.test(cmd))
+        if (/\byarn\s+(install|add|remove|upgrade|run\s|test\b|exec|publish|init|link|unlink|version)\b/i.test(cmd))
           return false;
         if (/\bnpx\b/.test(cmd))
           return false;
-        if (/\bcargo\s+(build|run|test|update|publish|install|uninstall|fmt|fix)\b/i.test(cmd))
+        if (/\bpip3?\s+(install|uninstall|wheel|download)\b/i.test(cmd))
+          return false;
+        if (/\bpipenv\s+(install|uninstall|run|update|sync)\b/i.test(cmd))
+          return false;
+        if (/\bpoetry\s+(add|install|run|update|remove|build|publish|init|new|export|lock)\b/i.test(cmd))
+          return false;
+        if (/\bconda\s+(install|remove|update|create|env\s+(create|update|remove))\b/i.test(cmd))
+          return false;
+        if (/\buv\s+(add|remove|sync|install|run|build|publish|pip\s+install)\b/i.test(cmd))
+          return false;
+        if (/\bbundle\s+(install|update|exec|add|remove|init)\b/i.test(cmd))
+          return false;
+        if (/\bgem\s+(install|uninstall|update|build|push|owner)\b/i.test(cmd))
+          return false;
+        if (/\bcpan\b|\bcpanm\b|\bperl\s+-MCPAN\b/i.test(cmd))
+          return false;
+        if (/\bcomposer\s+(install|update|require|remove|create-project|dump-autoload|run-script)\b/i.test(cmd))
+          return false;
+        if (/\bdotnet\s+(build|run|test|publish|pack|restore|add|remove|new|tool\s+install)\b/i.test(cmd))
           return false;
-        if (/\bgo\s+(build|run|test|get|install)\b/i.test(cmd))
+        if (/\bcargo\s+(build|run|test|bench|update|publish|install|uninstall|fmt|fix|clippy\s+--fix|new|init|add|remove|generate-lockfile)\b/i.test(cmd))
           return false;
-        if (/\bdocker\s+(build|run|push|pull|exec|kill|stop|rm|rmi|tag)\b/i.test(cmd))
+        if (/\bgo\s+(build|run|test|get|install|generate|mod\s+(tidy|download|init|edit|vendor)|work\s+)\b/i.test(cmd))
           return false;
-        if (/\bkubectl\s+(apply|delete|create|edit|patch|scale|rollout|exec)\b/i.test(cmd))
+        if (/\bdocker\s+(build|run|push|pull|exec|kill|stop|rm|rmi|tag|create|cp|commit|save|load|import|export|network\s+create|volume\s+create|compose\s+(up|down|build|run|exec|restart))\b/i.test(cmd))
           return false;
-        if (/\bterraform\s+(apply|destroy|init|plan|import)\b/i.test(cmd))
+        if (/\bpodman\s+(build|run|push|pull|exec|kill|stop|rm|rmi|tag|create|commit)\b/i.test(cmd))
+          return false;
+        if (/\bkubectl\s+(apply|delete|create|edit|patch|scale|rollout|exec|cp|drain|cordon|uncordon|taint|label|annotate|set\s)\b/i.test(cmd))
+          return false;
+        if (/\bterraform\s+(apply|destroy|init|plan|import|taint|untaint|workspace\s+(new|delete)|state\s+(rm|mv|push|replace-provider))\b/i.test(cmd))
+          return false;
+        if (/\bpulumi\s+(up|destroy|new|stack\s+(rm|init)|config\s+set|policy\s+enable|import)\b/i.test(cmd))
+          return false;
+        if (/\baws\s+(?:\S+\s+)+(create|delete|put|update|run|start|stop|terminate|attach|detach|cp|sync|mv)\b/i.test(cmd))
+          return false;
+        if (/\bgcloud\s+(?:\S+\s+)+(create|delete|update|deploy|apply|set|enable|disable|attach|detach|reset|move|sign-in|sign-out)\b/i.test(cmd))
+          return false;
+        if (/\baz\s+(?:\S+\s+)+(create|delete|update|deploy|set|attach|detach|reset|move)\b/i.test(cmd))
+          return false;
+        if (/\beslint\s+[^|;&]*--fix\b/i.test(cmd))
+          return false;
+        if (/\bprettier\s+[^|;&]*--write\b/i.test(cmd))
+          return false;
+        if (/\bblack\s+(?!--check\b)/i.test(cmd))
+          return false;
+        if (/\bisort\s+(?!--check\b|--diff\b)/i.test(cmd))
+          return false;
+        if (/\bruff\s+(?:format\b|check\s+[^|;&]*--fix\b)/i.test(cmd))
+          return false;
+        if (/\bgofmt\s+-w\b/i.test(cmd))
+          return false;
+        if (/\brustfmt\s+(?!--check\b)/i.test(cmd))
+          return false;
+        if (/\b(node|python\d?|ruby|perl|bash|sh|zsh|dash|fish)\s+-(e|c)\b/.test(cmd))
+          return false;
+        if (/\bcurl\s+[^|]*\|\s*(bash|sh|zsh|fish|python\d?|ruby|node|perl)\b/i.test(cmd))
+          return false;
+        if (/\bgit\s+(add|commit|push|pull|fetch|clone|init|checkout|switch|restore|reset|rm|mv|merge|rebase|cherry-pick|revert|stash|apply|am|tag(?:\s+\S)?|notes|worktree\s+(add|remove)|gc|prune|repack|filter-branch|filter-repo|reflog\s+(delete|expire)|update-ref|update-index|symbolic-ref|hash-object\s+-w)\b/i.test(cmd))
+          return false;
+        if (/\bollama\s+(pull|push|run|create|rm|cp|serve)\b/i.test(cmd))
           return false;
         const READ_ONLY_BINS = /* @__PURE__ */ new Set([
           "cd",
@@ -518749,79 +518918,128 @@ ${body}`;
           "fgrep",
           "rg",
           "ag",
+          "ack",
           "cat",
           "head",
           "tail",
           "less",
           "more",
+          "bat",
+          "tac",
           "ls",
           "ll",
           "la",
+          "tree",
           "find",
-          // ALLOWED only if no -delete/-exec mutating action — pre-filtered above
+          "fd",
+          // mutating actions pre-filtered above
           "wc",
           "awk",
           "gawk",
+          "mawk",
+          "nawk",
           "sort",
           "uniq",
+          "shuf",
           "tr",
           "cut",
           "paste",
           "join",
           "comm",
+          "column",
+          "expand",
+          "unexpand",
           "diff",
           "cmp",
+          "patch",
+          // patch with -R or no-args could be mutating; --dry-run only is read
           "echo",
           "printf",
           "pwd",
           "which",
           "type",
           "command",
-          "node",
-          "python",
-          "python3",
-          "ruby",
-          "perl",
+          "whereis",
           "git",
-          // git log/show/diff/status are read; but git add/commit/push/pull are writes — pre-filtered above
+          // pre-filtered above for mutating subcommands
           "ollama",
-          // ollama show/list are read; ollama pull/run/create are writes — pre-filtered above
+          // pre-filtered above
           "cargo",
-          // pre-filtered above for build/run/etc.
           "go",
-          // pre-filtered above for build/run/etc.
+          "rustc",
+          // bin-only forms are read; mutating subcommands pre-filtered
           "stat",
           "file",
           "du",
           "df",
+          "lsof",
+          "fuser",
           "date",
           "uname",
           "id",
           "whoami",
           "hostname",
           "uptime",
+          "tty",
           "env",
           "printenv",
+          "set",
           "test",
           "[",
           "true",
           "false",
+          "yes",
+          "seq",
           "tsc",
           "eslint",
           "prettier",
-          // these emit but mostly read
-          "head",
-          "tail",
+          "ruff",
+          "black",
+          "isort",
+          "rustfmt",
+          "gofmt",
+          // Linters/formatters: mutating modes pre-filtered above (--fix/--write/-w/-i),
+          // so reaching here means we have a check-only invocation.
           "jq",
           "yq",
           "xq",
+          "tomlq",
+          "fx",
           "base64",
           "md5sum",
           "sha256sum",
           "sha1sum",
+          "sha512sum",
           "tldr",
           "man",
-          "info"
+          "info",
+          "help",
+          "pip",
+          "pip3",
+          "pipenv",
+          "poetry",
+          "uv",
+          "conda",
+          // pre-filtered above for mutating subcommands
+          "npm",
+          "pnpm",
+          "yarn",
+          // pre-filtered above
+          "kubectl",
+          "terraform",
+          "pulumi",
+          "aws",
+          "gcloud",
+          "az",
+          // pre-filtered above
+          "docker",
+          "podman",
+          // pre-filtered above
+          "composer",
+          "dotnet",
+          "bundle",
+          "gem"
+          // pre-filtered above
         ]);
         if (/\bfind\b[\s\S]*?(-delete|-exec\s+(rm|mv|cp|chmod|chown|sed\s+-i)|--?ok\s+(rm|mv))/i.test(cmd))
           return false;
@@ -518830,11 +519048,42 @@ ${body}`;
         const segments = cmd.split(/(?:\|\||&&|;)/).map((s2) => s2.trim()).filter(Boolean);
         if (segments.length === 0)
           return false;
+        const SAFE_INTERP_FLAGS = /^(?:--version|--help|-V|-v|-h|--vers|version)$/;
+        const INTERPRETER_BINS = /* @__PURE__ */ new Set([
+          "node",
+          "python",
+          "python2",
+          "python3",
+          "ruby",
+          "perl",
+          "php",
+          "lua",
+          "bash",
+          "sh",
+          "zsh",
+          "dash",
+          "fish",
+          "ksh",
+          "tcsh",
+          "java",
+          "kotlin",
+          "scala",
+          "groovy"
+        ]);
         for (const seg of segments) {
           const stripped = seg.replace(/^cd\s+\S+\s*$/i, "true").replace(/^!/, "");
-          const firstTok = stripped.split(/\s+/)[0]?.replace(/^.*\//, "") || "";
+          const tokens = stripped.split(/\s+/).filter(Boolean);
+          const firstTok = (tokens[0] ?? "").replace(/^.*\//, "");
           if (!firstTok)
             continue;
+          if (INTERPRETER_BINS.has(firstTok)) {
+            const restToks = tokens.slice(1);
+            if (restToks.length === 0)
+              return false;
+            if (!restToks.every((t2) => SAFE_INTERP_FLAGS.test(t2)))
+              return false;
+            continue;
+          }
           if (!READ_ONLY_BINS.has(firstTok))
             return false;
         }
@@ -518843,10 +519092,11 @@ ${body}`;
       /**
        * REG-5: Render the recent-failures block so the agent SEES its own error
        * output before deciding what to do next. Detects same-fingerprint failure
-       * repetition and escalates the warning. Without this, the agent runs
-       * `npx next build`, gets a 200-line TypeScript error, ignores the specific
-       * error and blindly retries with `npm install --force`. Caching the failure
-       * + injecting it pre-LLM forces the model to confront what actually broke.
+       * repetition and escalates the warning. Without this, the agent runs a
+       * build/test/install command, gets a long error stream from the
+       * underlying compiler/runner, ignores the specific error, and blindly
+       * retries with a different flag combination. Caching the failure +
+       * injecting it pre-LLM forces the model to confront what actually broke.
        */
       _renderRecentFailuresBlock(turn) {
         const fails = this._recentFailures;
@@ -520429,6 +520679,8 @@ ${memoryLines.join("\n")}`
                   for (const [tool2, budget] of Object.entries(toolBudgets)) {
                     toolCallBudget.set(tool2, budget);
                   }
+                  this._writesSinceLastTodoWrite = 0;
+                  this._progressGateActive = false;
                   this.emit({
                     type: "status",
                     content: `Tool budgets reset for new phase (${Object.keys(toolBudgets).length} tools)`,
@@ -520436,6 +520688,55 @@ ${memoryLines.join("\n")}`
                   });
                 }
               }
+              const PROGRESS_GATE_BYPASS_TOOLS = /* @__PURE__ */ new Set([
+                "todo_write",
+                "todo_read",
+                "task_complete",
+                "ask_user",
+                "phase_recall"
+                // useful for the agent to consult prior phase state before updating
+              ]);
+              if (this._progressGateActive && !PROGRESS_GATE_BYPASS_TOOLS.has(tc.name)) {
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                const recentWrites = [];
+                for (const [path8, info] of this._worldFacts.files) {
+                  if ((info.writeCount ?? 0) > 0 && (info.lastWriteTurn ?? -1) >= 0 && turn - (info.lastWriteTurn ?? 0) <= 8) {
+                    recentWrites.push({ path: path8, turn: info.lastWriteTurn ?? 0 });
+                  }
+                }
+                recentWrites.sort((a2, b) => b.turn - a2.turn);
+                const showWrites = recentWrites.slice(0, 16);
+                const gateMsg = [
+                  `[PROGRESS GATE — call todo_write FIRST before any other tool]`,
+                  ``,
+                  `You have completed ${this._writesSinceLastTodoWrite} file modification${this._writesSinceLastTodoWrite === 1 ? "" : "s"} since your last todo_write call.`,
+                  `The next tool call MUST be todo_write to mark progress. This is enforced — non-todo tool calls are intercepted until plan state is updated.`,
+                  ``,
+                  `Recent file modifications (use these to decide what's done):`,
+                  ...showWrites.map((w) => `  • ${w.path} (turn ${w.turn})`),
+                  recentWrites.length > showWrites.length ? `  • ... +${recentWrites.length - showWrites.length} more` : "",
+                  ``,
+                  `Required action: call todo_write with the updated todo array — mark anything completed that these writes satisfy, advance the next item to in_progress, keep the rest pending.`,
+                  `After todo_write succeeds, this gate releases and you can continue normal work.`,
+                  ``,
+                  `Why this exists: without the explicit progress update, your next turn will see the same in_progress todo, re-plan the same work, and re-emit identical tool calls (the "plan replay" failure mode that causes byte-identical writes to appear twice).`
+                ].filter(Boolean).join("\n");
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: gateMsg.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: gateMsg };
+              }
               const _argsKeyForBudget = `${tc.name}:${argsKey}`;
               const _isCachedHit = recentToolResults.has(_argsKeyForBudget);
               const budgetRemaining = toolCallBudget.get(tc.name);
@@ -520654,10 +520955,26 @@ ${cachedEntry2.result.slice(0, 500)}` : `[BLOCKED — the observer confirmed thi
                       writeCount: (prev?.writeCount ?? 0) + 1
                     });
                     this._writesSinceLastTodoWrite++;
+                    if (this._writesSinceLastTodoWrite >= 6 && !this._progressGateActive) {
+                      this._progressGateActive = true;
+                      this.emit({
+                        type: "status",
+                        content: `Progress gate engaged at ${this._writesSinceLastTodoWrite} writes without todo_write — non-todo tools will be blocked until plan is updated`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
                   }
                 }
                 if (tc.name === "todo_write" && result.success) {
+                  if (this._progressGateActive) {
+                    this.emit({
+                      type: "status",
+                      content: "Progress gate released — todo_write acknowledged",
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
                   this._writesSinceLastTodoWrite = 0;
+                  this._progressGateActive = false;
                 }
                 if (tc.name === "file_read") {
                   const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "");

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.467",
+  "version": "0.187.469",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.467",
+      "version": "0.187.469",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.467",
+  "version": "0.187.469",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",