open-agents-ai 0.187.467 → 0.187.468

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
@@ -520429,6 +520438,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 +520447,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 +520714,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.468",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.467",
+      "version": "0.187.468",
       "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.468",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",