open-agents-ai 0.187.523 → 0.187.525

package/dist/index.js

@@ -525987,6 +525987,20 @@ var init_agenticRunner = __esm({
       // updated directive text names the 4 valid creative-edit tools and
       // explicitly excludes todo_write/memory_write/list_directory.
       _reg61CooldownUntilTurn = -1;
+      // BFC-61.E (root-cause from batch528-midi-bfc61, 2026-05-03): REG-61
+      // runtime coercion. Empirical: in batch528 the agent received 5 REG-61
+      // firings in main loop and ignored ALL of them while in vitest-debug-loop
+      // mode (0 edits in 65 tool calls). REG-61 is informational; the agent
+      // rationally ignores it when it believes "I need to read more to debug".
+      // This counter escalates REG-61 to runtime enforcement: when REG-61
+      // fires, _reg61BlocksRemaining is set to 1. The dispatch site checks: if
+      // blocks remain AND incoming tool is non-edit, BLOCK with a synthetic
+      // [BLOCKED — REG-61 directive in effect] error and decrement. If the
+      // incoming tool IS an edit, the counter clears (directive satisfied).
+      // One block per fire — not a perpetual gate; the agent's NEXT call
+      // after the block can be anything (until the NEXT REG-61 fire 5+ turns
+      // later). Kill switch: OA_DISABLE_REG61_COERCE=1.
+      _reg61BlocksRemaining = 0;
       // 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
       // the previous memoryLines.
@@ -526383,6 +526397,125 @@ Your hypotheses MUST address this specific error, not generic causes.
           return null;
         }
       }
+      /**
+       * REG-61 sliding-window first-edit / sustained-edit nudge.
+       *
+       * Fires when:
+       *   • turn ≥ 4 (give the agent a few turns to orient)
+       *   • EITHER this run has zero creative edits OR the last creative edit
+       *     was ≥ 5 turns ago (re-fires when agent slips back into read mode)
+       *   • there have been ≥ 3 read-class tool calls in the trailing window
+       *     (since the last creative edit)
+       *   • not in the 5-turn cooldown after a previous firing
+       *
+       * Why earlier than REG-44/REG-58: by turn 12 the read habit is locked in
+       * and prompts get ignored. Re-fire-with-cooldown handles the batch524 stax
+       * case where one early file_write satisfied the initial gate, then the
+       * agent spent 22 turns re-reading source. Directive text names the 4 valid
+       * creative-edit tools EXPLICITLY and lists todo_write as NOT counting
+       * (batch524 osm responded to the original directive with todo_write
+       * thinking it qualified). Generic across ecosystems — no manifest/file/
+       * language keywords.
+       *
+       * BFC-61 (root-cause from batch527-midi-solo): refactored from inline
+       * block in the main turn loop into this method so the brute-force
+       * re-engagement inner loop can also invoke it. Without BFC-61, REG-61
+       * stops checking once the runner enters brute-force cycles, allowing
+       * 30+ minutes of read-paralysis (batch527 hit this — 804 consecutive
+       * non-edit calls in brute-force, REG-61 fired 0× in that phase).
+       *
+       * Side effects when firing:
+       *   - bumps `this._reg61CooldownUntilTurn`
+       *   - pushes a system message with the directive into `messages`
+       *   - emits a `status` event with telemetry (turn, reads_in_window, gap)
+       *
+       * State (instance fields, persist across cycles — desired):
+       *   - `_lastFileWriteTurn`: bumped by tool dispatch on creative edits
+       *   - `_reg61CooldownUntilTurn`: bumped by this method when firing
+       *
+       * @param turn - Current turn counter from the enclosing loop. In
+       *               brute-force cycles this resets to 0 each cycle, but the
+       *               cooldown / lastFileWriteTurn state is retained across
+       *               cycles via instance fields, so behavior is consistent.
+       * @param toolCallLog - Append-only ordered tool-call history.
+       * @param messages - Conversation history to inject the system directive into.
+       * @param cycleLabel - Optional label to disambiguate brute-force fires
+       *               from main-loop fires in the status emit (e.g. "bf-cycle 2").
+       */
+      _runReg61Check(turn, toolCallLog, messages2, cycleLabel) {
+        const REG61_TURN_FLOOR = 4;
+        const REG61_MIN_READS = 3;
+        const REG61_NO_WRITE_GAP = 5;
+        const REG61_COOLDOWN = 5;
+        if (process.env["OA_DISABLE_REG61"] === "1")
+          return;
+        if (turn < REG61_TURN_FLOOR)
+          return;
+        if (turn <= this._reg61CooldownUntilTurn)
+          return;
+        const _writeGate = this._lastFileWriteTurn < 0 || turn - this._lastFileWriteTurn >= REG61_NO_WRITE_GAP;
+        if (!_writeGate)
+          return;
+        const _readClassNames = /* @__PURE__ */ new Set([
+          "file_read",
+          "file_explore",
+          "list_directory",
+          "grep_search",
+          "glob_find",
+          "find_files",
+          "code_neighbors",
+          "repo_map",
+          "codebase_map",
+          "semantic_map",
+          "symbol_search",
+          "todo_read",
+          "memory_read",
+          "memory_search"
+        ]);
+        const _editClassNames = /* @__PURE__ */ new Set([
+          "file_write",
+          "file_edit",
+          "batch_edit",
+          "file_patch"
+        ]);
+        let _readsInWindow = 0;
+        for (let k = toolCallLog.length - 1; k >= 0; k--) {
+          const _name = toolCallLog[k].name;
+          if (_editClassNames.has(_name))
+            break;
+          if (_readClassNames.has(_name))
+            _readsInWindow++;
+        }
+        if (_readsInWindow < REG61_MIN_READS)
+          return;
+        this._reg61CooldownUntilTurn = turn + REG61_COOLDOWN;
+        if (process.env["OA_DISABLE_REG61_COERCE"] !== "1") {
+          this._reg61BlocksRemaining = 1;
+        }
+        const _gapDesc = this._lastFileWriteTurn < 0 ? `no creative edits yet this run` : `${turn - this._lastFileWriteTurn} turns since last creative edit (turn ${this._lastFileWriteTurn})`;
+        const reg61Msg = `[FIRST-EDIT NUDGE — REG-61]
+You have made ${_readsInWindow} read/exploration calls in the trailing window — ${_gapDesc}. Reading is preparation; writing is progress. Runs that stay in pure-read mode produce zero deliverables.
+
+Your NEXT tool call MUST be EXACTLY ONE of:
+  • file_write   — create a new file
+  • file_edit    — modify an existing file (find/replace)
+  • batch_edit   — multiple find/replace edits in one call
+  • file_patch   — apply a unified diff
+
+These are the ONLY four tools that count as creative edits. The following do NOT count and will NOT satisfy this directive:
+  • todo_write    (only updates the todo list, not the filesystem)
+  • memory_write  (writes to memory store, not the project)
+  • list_directory / file_read / file_explore / grep_search / shell
+
+Pick the SMALLEST concrete deliverable from the spec — typically the project entry point or the file most other modules depend on. Write a stub or skeleton if the full implementation is too large; you can iterate later. Do NOT issue another read or todo update before producing the next file_write/file_edit/batch_edit/file_patch.`;
+        messages2.push({ role: "system", content: reg61Msg });
+        const _cyclePart = cycleLabel ? ` (${cycleLabel})` : "";
+        this.emit({
+          type: "status",
+          content: `REG-61 FIRST-EDIT NUDGE — fired at turn ${turn}${_cyclePart}; reads_in_window=${_readsInWindow}; ${_gapDesc}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       readSessionTodos() {
         try {
           const sid = process.env["OA_SESSION_ID"] || this._sessionId || "default";
@@ -528197,6 +528330,7 @@ Respond with your assessment, then take action.`;
         this._fileWriteTimestamps = [];
         this._aborting = false;
         this._reg61CooldownUntilTurn = -1;
+        this._reg61BlocksRemaining = 0;
         if (!globalThis.__oa_rca1_sigterm_installed) {
           globalThis.__oa_rca1_sigterm_installed = true;
           const _sigtermHandler = () => {
@@ -528620,70 +528754,7 @@ TASK: ${task}` : task;
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          const REG61_TURN_FLOOR = 4;
-          const REG61_MIN_READS = 3;
-          const REG61_NO_WRITE_GAP = 5;
-          const REG61_COOLDOWN = 5;
-          if (turn >= REG61_TURN_FLOOR && turn > this._reg61CooldownUntilTurn && process.env["OA_DISABLE_REG61"] !== "1") {
-            const _writeGate = this._lastFileWriteTurn < 0 || turn - this._lastFileWriteTurn >= REG61_NO_WRITE_GAP;
-            if (_writeGate) {
-              const _readClassNames = /* @__PURE__ */ new Set([
-                "file_read",
-                "file_explore",
-                "list_directory",
-                "grep_search",
-                "glob_find",
-                "find_files",
-                "code_neighbors",
-                "repo_map",
-                "codebase_map",
-                "semantic_map",
-                "symbol_search",
-                "todo_read",
-                "memory_read",
-                "memory_search"
-              ]);
-              let _readsInWindow = 0;
-              const _editClassNames = /* @__PURE__ */ new Set([
-                "file_write",
-                "file_edit",
-                "batch_edit",
-                "file_patch"
-              ]);
-              for (let k = toolCallLog.length - 1; k >= 0; k--) {
-                const _name = toolCallLog[k].name;
-                if (_editClassNames.has(_name))
-                  break;
-                if (_readClassNames.has(_name))
-                  _readsInWindow++;
-              }
-              if (_readsInWindow >= REG61_MIN_READS) {
-                this._reg61CooldownUntilTurn = turn + REG61_COOLDOWN;
-                const _gapDesc = this._lastFileWriteTurn < 0 ? `no creative edits yet this run` : `${turn - this._lastFileWriteTurn} turns since last creative edit (turn ${this._lastFileWriteTurn})`;
-                const reg61Msg = `[FIRST-EDIT NUDGE — REG-61]
-You have made ${_readsInWindow} read/exploration calls in the trailing window — ${_gapDesc}. Reading is preparation; writing is progress. Runs that stay in pure-read mode produce zero deliverables.
-
-Your NEXT tool call MUST be EXACTLY ONE of:
-  • file_write   — create a new file
-  • file_edit    — modify an existing file (find/replace)
-  • batch_edit   — multiple find/replace edits in one call
-  • file_patch   — apply a unified diff
-
-These are the ONLY four tools that count as creative edits. The following do NOT count and will NOT satisfy this directive:
-  • todo_write    (only updates the todo list, not the filesystem)
-  • memory_write  (writes to memory store, not the project)
-  • list_directory / file_read / file_explore / grep_search / shell
-
-Pick the SMALLEST concrete deliverable from the spec — typically the project entry point or the file most other modules depend on. Write a stub or skeleton if the full implementation is too large; you can iterate later. Do NOT issue another read or todo update before producing the next file_write/file_edit/batch_edit/file_patch.`;
-                messages2.push({ role: "system", content: reg61Msg });
-                this.emit({
-                  type: "status",
-                  content: `REG-61 FIRST-EDIT NUDGE — fired at turn ${turn}; reads_in_window=${_readsInWindow}; ${_gapDesc}`,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              }
-            }
-          }
+          this._runReg61Check(turn, toolCallLog, messages2);
           const REG58_NO_WRITE_BUDGET = 30;
           if (turn > stagnationCooldownUntilTurn && this._lastFileWriteTurn >= 0 && turn - this._lastFileWriteTurn >= REG58_NO_WRITE_BUDGET && process.env["OA_DISABLE_REG58"] !== "1") {
             const gap = turn - this._lastFileWriteTurn;
@@ -530288,6 +530359,59 @@ ${memoryLines.join("\n")}`
                   });
                 }
               }
+              const REG61_EDIT_TOOLS = /* @__PURE__ */ new Set([
+                "file_write",
+                "file_edit",
+                "batch_edit",
+                "file_patch"
+              ]);
+              if (this._reg61BlocksRemaining > 0 && process.env["OA_DISABLE_REG61_COERCE"] !== "1") {
+                if (REG61_EDIT_TOOLS.has(tc.name)) {
+                  this._reg61BlocksRemaining = 0;
+                } else {
+                  this._reg61BlocksRemaining--;
+                  this.emit({
+                    type: "tool_call",
+                    toolName: tc.name,
+                    toolArgs: tc.arguments,
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  const reg61BlockMsg = [
+                    `[BLOCKED — REG-61 directive in effect]`,
+                    ``,
+                    `Your previous turn received a REG-61 FIRST-EDIT NUDGE telling you the next tool call MUST be a creative edit. You issued '${tc.name}' instead, which is a read/explore/shell call. This call has been BLOCKED.`,
+                    ``,
+                    `Issue EXACTLY ONE of these on your next turn:`,
+                    `  • file_write   — create a new file`,
+                    `  • file_edit    — modify an existing file (find/replace)`,
+                    `  • batch_edit   — multiple find/replace edits in one call`,
+                    `  • file_patch   — apply a unified diff`,
+                    ``,
+                    `Pick the smallest concrete change that moves work forward — even a partial stub or a single-line edit counts. Reading more without writing has been demonstrated (in your trailing window) to produce zero deliverables.`,
+                    ``,
+                    `If you genuinely cannot make ANY change without more information (e.g., truly unknown API), call web_search with the specific question. todo_write, list_directory, file_read, file_explore, grep_search, and shell will all be blocked again until an edit lands.`
+                  ].join("\n");
+                  this.emit({
+                    type: "tool_result",
+                    toolName: tc.name,
+                    success: false,
+                    content: reg61BlockMsg.slice(0, 120),
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  this.emit({
+                    type: "status",
+                    content: `REG-61 COERCION BLOCK — rejected '${tc.name}' at turn ${turn}; agent must issue file_write/file_edit/batch_edit/file_patch next`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  this._tagSyntheticFailure({
+                    mode: "step_repetition",
+                    rationale: `REG-61 coercion block on '${tc.name}' — agent ignored FIRST-EDIT NUDGE`
+                  });
+                  return { tc, output: reg61BlockMsg };
+                }
+              }
               const PROGRESS_GATE_BYPASS_TOOLS = /* @__PURE__ */ new Set([
                 "todo_write",
                 "todo_read",
@@ -532118,6 +532242,7 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
             content: `Re-engaging — cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} tool calls so far)`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
+          this._reg61CooldownUntilTurn = -1;
           messages2.push({
             role: "user",
             content: `[CONTINUATION — Cycle ${bruteForceCycle}]
@@ -532151,6 +532276,7 @@ You have ${this.options.maxTurns} more turns. Continue making progress. Call tas
               this.emit({ type: "error", content: "Task aborted by user", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
               break;
             }
+            this._runReg61Check(turn, toolCallLog, messages2, `bf-cycle ${bruteForceCycle}`);
             const bfNow = Date.now();
             if (bfNow > nextSelfEval) {
               selfEvalCount++;

package/npm-shrinkwrap.json

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

package/package.json

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