open-agents-ai 0.187.574 → 0.187.575

package/dist/index.js

@@ -528111,6 +528111,10 @@ var init_agenticRunner = __esm({
       // can re-emit the same plan a second time (plan-replay) and execute
       // duplicate work because PROGRESS NUDGE alone is informational.
       _progressGateActive = false;
+      // Consecutive gate blocks count. When the model ignores the gate and
+      // retries a blocked tool, this counter increments. ≥2 triggers a system
+      // message escalation to break pattern-lock loops.
+      _consecutiveGateBlocks = 0;
       // 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
@@ -528360,15 +528364,19 @@ var init_agenticRunner = __esm({
       // DECOMP-2 (root-cause from batch531-midi-decomp, 2026-05-03): compelling
       // sub_agent delegation. DECOMP-1's informational directive was ignored
       // (0 sub_agent calls in 466 tool-call run despite directive at turn 1).
-      // Mirrors the BFC-61.G escalation arc: when the agent has edited
-      // ≥THRESHOLD distinct files in main context WITHOUT successful sub_agent,
+      // Mirrors the BFC-61.G escalation arc, but must not deadlock delivery:
+      // when the agent has edited ≥adaptive-threshold distinct files in main context
+      // WITHOUT successful sub_agent,
       // the dispatcher BLOCKS edits to NEW files (paths not yet edited) until
       // sub_agent succeeds. Edits to already-touched files are still allowed
-      // (current-module finishing work). Failed or malformed delegation does
-      // not clear the gate.
+      // (current-module finishing work). Repeated failed delegation attempts
+      // unlock a main-context fallback so the guardrail cannot become a hard
+      // write-deadlock when sub_agent itself is broken or unavailable.
       // Kill switch: OA_DISABLE_DECOMP2=1.
       _decomp2MainContextFiles = /* @__PURE__ */ new Set();
       _decomp2SubAgentCalls = 0;
+      _decomp2FailedDelegationCalls = 0;
+      _decomp2FallbackAllowed = false;
       _decomp2GateActive = false;
       // MEM_PATH item #9: adaptive retrieval cache. When the (goalHash, recent-tool-sig)
       // hasn't changed since last retrieval, skip the PPR call entirely and reuse
@@ -528913,6 +528921,8 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
       _maybeDecomp2Block(tc, turn) {
         if (!this._decomp2GateActive)
           return null;
+        if (this._decomp2FallbackAllowed)
+          return null;
         if (process.env["OA_DISABLE_DECOMP2"] === "1")
           return null;
         const _editTools = /* @__PURE__ */ new Set([
@@ -528933,7 +528943,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         const decomp2Msg = [
           `[BLOCKED — DECOMP-2 main-context exhaustion]`,
           ``,
-          `You have already edited ${this._decomp2MainContextFiles.size} distinct files in main context without invoking sub_agent. Continuing to edit ANOTHER new file ('${_editPath}') will keep your context window saturated and trigger compaction thrashing.`,
+          `You have already edited ${this._decomp2MainContextFiles.size} distinct files in main context without a successful sub_agent. Continuing to edit another new file ('${_editPath}') may keep your context window saturated and trigger compaction thrashing.`,
           ``,
           `Files you've already edited (will accept further edits to these):`,
           _filesList,
@@ -528949,13 +528959,15 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           `     })`,
           `  3. After sub_agent returns, mark the todo completed.`,
           ``,
+          `If sub_agent keeps failing for reasons outside the module work, retry it once with corrected arguments. After repeated failed delegation attempts, OA will downgrade this from a hard block to an advisory fallback so file writes can continue.`,
+          ``,
           `Why this matters: spreading edits across N files in main context burns ~N × file_size tokens. sub_agent gives the next module a focused context window.`,
           ``,
           `If you have ALREADY edited '${_editPath}' (this is a continuation), the orchestrator's set must have missed it — call file_read to verify, then re-edit. Otherwise, dispatch sub_agent now.`
         ].join("\n");
         this.emit({
           type: "status",
-          content: `DECOMP-2 NEW-FILE BLOCK — rejected ${tc.name}('${_editPath}') at turn ${turn}; gate stays active until sub_agent succeeds`,
+          content: `DECOMP-2 NEW-FILE BLOCK — rejected ${tc.name}('${_editPath}') at turn ${turn}; gate stays active until sub_agent succeeds or repeated delegation failure unlocks fallback`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         this._tagSyntheticFailure({
@@ -528964,6 +528976,12 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         });
         return decomp2Msg;
       }
+      _decomp2FileSpreadThreshold() {
+        const ctx3 = this.options.contextWindowSize ?? 0;
+        if (ctx3 <= 0)
+          return 5;
+        return Math.max(5, Math.min(30, Math.round(ctx3 / 6400)));
+      }
       /**
        * DECOMP-2 post-dispatch tracking. Refactored from inline so both the
        * main turn loop AND the brute-force re-engagement inner loop record
@@ -528990,12 +529008,12 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           const _editPaths = this._extractToolTargetPaths(tc.name, tc.arguments, result);
           for (const _editPath of _editPaths) {
             this._decomp2MainContextFiles.add(_editPath);
-            const DECOMP2_FILE_SPREAD_THRESHOLD = 5;
-            if (!this._decomp2GateActive && this._decomp2MainContextFiles.size >= DECOMP2_FILE_SPREAD_THRESHOLD && this._decomp2SubAgentCalls === 0) {
+            const DECOMP2_FILE_SPREAD_THRESHOLD = this._decomp2FileSpreadThreshold();
+            if (!this._decomp2GateActive && !this._decomp2FallbackAllowed && this._decomp2MainContextFiles.size >= DECOMP2_FILE_SPREAD_THRESHOLD && this._decomp2SubAgentCalls === 0) {
               this._decomp2GateActive = true;
               this.emit({
                 type: "status",
-                content: `DECOMP-2 NEW-FILE GATE ACTIVATED — ${this._decomp2MainContextFiles.size} distinct files edited in main context, 0 successful sub_agent calls; further edits to NEW files will be blocked until sub_agent succeeds`,
+                content: `DECOMP-2 NEW-FILE GATE ACTIVATED — ${this._decomp2MainContextFiles.size} distinct files edited in main context, 0 successful sub_agent calls, threshold=${DECOMP2_FILE_SPREAD_THRESHOLD}; further edits to NEW files will be blocked until sub_agent succeeds or repeated delegation failure unlocks fallback`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
@@ -529004,15 +529022,27 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (tc.name === "sub_agent" || tc.name === "priority_delegate" || tc.name === "background_run") {
           if (result?.success !== true) {
             if (this._decomp2GateActive) {
+              this._decomp2FailedDelegationCalls++;
               this.emit({
                 type: "status",
                 content: `DECOMP-2 DELEGATION FAILED — '${tc.name}' did not clear gate at turn ${turn}; fix delegation arguments/result before editing another new file`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              if (this._decomp2FailedDelegationCalls >= 2) {
+                this._decomp2FallbackAllowed = true;
+                this._decomp2GateActive = false;
+                this.emit({
+                  type: "status",
+                  content: `DECOMP-2 FALLBACK UNLOCKED — ${this._decomp2FailedDelegationCalls} failed delegation attempts while gate was active; allowing main-context new-file edits so work can continue`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
             }
             return;
           }
           this._decomp2SubAgentCalls++;
+          this._decomp2FailedDelegationCalls = 0;
+          this._decomp2FallbackAllowed = false;
           if (this._decomp2GateActive) {
             this._decomp2GateActive = false;
             this.emit({
@@ -531100,6 +531130,8 @@ Respond with your assessment, then take action.`;
         this._reg61PerpetualGateActive = false;
         this._decomp2MainContextFiles = /* @__PURE__ */ new Set();
         this._decomp2SubAgentCalls = 0;
+        this._decomp2FailedDelegationCalls = 0;
+        this._decomp2FallbackAllowed = false;
         this._decomp2GateActive = false;
         if (!globalThis.__oa_rca1_sigterm_installed) {
           globalThis.__oa_rca1_sigterm_installed = true;
@@ -533438,22 +533470,25 @@ ${memoryLines.join("\n")}`
                     recentWrites.push({ path: path11, turn: info.lastWriteTurn ?? 0 });
                   }
                 }
+                this._consecutiveGateBlocks++;
                 recentWrites.sort((a2, b) => b.turn - a2.turn);
                 const showWrites = recentWrites.slice(0, 16);
+                const isRepeat = this._consecutiveGateBlocks >= 2;
                 const gateMsg = [
-                  `[PROGRESS GATE — call todo_write FIRST before any other tool]`,
+                  `[BLOCKED — PROGRESS GATE active]`,
                   ``,
-                  `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.`,
+                  `CAUSE: ${this._writesSinceLastTodoWrite} file writes since last todo_write call. Without progress tracking, the next turn re-plans the same work (plan-replay).`,
+                  `EFFECT: All non-todo tool calls are now blocked at the runtime level.`,
+                  `ACTION REQUIRED: Call todo_write with updated progress to release the gate.`,
+                  `CONSEQUENCE OF IGNORING: Retrying blocked tools does NOT work — only todo_write is accepted while the gate is active.`,
+                  isRepeat ? `
+[ESCALATION: This is block #${this._consecutiveGateBlocks}. You keep calling blocked tools instead of todo_write. The gate cannot be bypassed. You MUST call todo_write next.]` : "",
                   ``,
                   `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).`
+                  `Format: todo_write with todos array — mark items completed that these writes satisfy, advance next to in_progress. After todo_write succeeds, normal tools resume.`
                 ].filter(Boolean).join("\n");
                 this.emit({
                   type: "tool_result",
@@ -533939,6 +533974,7 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                   this._writesSinceLastTodoWrite = 0;
                   this._progressGateActive = false;
+                  this._consecutiveGateBlocks = 0;
                 }
                 if (tc.name === "file_read") {
                   const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "");
@@ -534947,6 +534983,12 @@ Then use file_read on individual FILES inside it.`);
                   const output = sr.result.success ? sr.result.output : `Error: ${sr.result.error || "unknown"}
 ${sr.result.output}`;
                   messages2.push(this.buildToolMessage(output, matchTc.id, matchTc.name));
+                  if (this._consecutiveGateBlocks >= 2 && this._progressGateActive) {
+                    messages2.push({
+                      role: "system",
+                      content: `[PROGRESS GATE ESCALATION] You have made ${this._consecutiveGateBlocks} consecutive blocked tool calls without calling todo_write. The gate is enforced at the runtime level — retrying the same blocked tool will never work. Your NEXT call MUST be todo_write(todos=[...]) with updated progress. No other tool will be accepted until the gate is released.`
+                    });
+                  }
                   if (matchTc.name === "task_complete") {
                     const open2 = this.getOpenTodoItems();
                     if (open2.length > 0) {
@@ -534987,6 +535029,12 @@ ${sr.result.output}`;
                   const r2 = await executeSingle(tc);
                   if (r2) {
                     messages2.push(this.buildToolMessage(r2.output, r2.tc.id, r2.tc.name));
+                    if (this._consecutiveGateBlocks >= 2 && this._progressGateActive) {
+                      messages2.push({
+                        role: "system",
+                        content: `[PROGRESS GATE ESCALATION] You have made ${this._consecutiveGateBlocks} consecutive blocked tool calls without calling todo_write. The gate is enforced at the runtime level — retrying the same blocked tool will never work. Your NEXT call MUST be todo_write(todos=[...]) with updated progress. No other tool will be accepted until the gate is released.`
+                      });
+                    }
                     if (r2.tc.name === "task_complete") {
                       const open2 = this.getOpenTodoItems();
                       if (open2.length > 0) {

package/npm-shrinkwrap.json

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

package/package.json

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