open-agents-ai 0.187.525 → 0.187.526

package/dist/index.js

@@ -525987,20 +525987,24 @@ 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;
+      // BFC-61.G (root-cause from batch529-midi-coerce, 2026-05-03): REG-61
+      // PERPETUAL gate until obeyed. Replaces BFC-61.E's one-shot counter,
+      // which empirically warned but did not change behavior — agents took
+      // the [BLOCKED] tool_result and on the very next turn issued ANOTHER
+      // read (counter cleared, gate inert). batch529 measured 6 blocks across
+      // 7 fires; ZERO of those blocks were followed by a creative edit on
+      // the agent's next turn.
+      //
+      // Semantics: when REG-61 fires, this latch goes true. While true, every
+      // non-bypass tool call gets BLOCKED with a synthetic error result. The
+      // bypass set includes the 4 creative-edit tools plus web_search /
+      // task_complete / ask_user (escape hatches). Any creative edit dispatch
+      // clears the latch ("directive satisfied"). Shell, file_read, todo_*,
+      // grep_search, list_directory etc. are NOT in bypass — those are the
+      // exact patterns batch528/529 agents used to ignore REG-61.
+      //
+      // Kill switch: OA_DISABLE_REG61_COERCE=1 disables BOTH set and enforce.
+      _reg61PerpetualGateActive = 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
       // the previous memoryLines.
@@ -526490,7 +526494,7 @@ Your hypotheses MUST address this specific error, not generic causes.
           return;
         this._reg61CooldownUntilTurn = turn + REG61_COOLDOWN;
         if (process.env["OA_DISABLE_REG61_COERCE"] !== "1") {
-          this._reg61BlocksRemaining = 1;
+          this._reg61PerpetualGateActive = true;
         }
         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]
@@ -528330,7 +528334,7 @@ Respond with your assessment, then take action.`;
         this._fileWriteTimestamps = [];
         this._aborting = false;
         this._reg61CooldownUntilTurn = -1;
-        this._reg61BlocksRemaining = 0;
+        this._reg61PerpetualGateActive = false;
         if (!globalThis.__oa_rca1_sigterm_installed) {
           globalThis.__oa_rca1_sigterm_installed = true;
           const _sigtermHandler = () => {
@@ -530365,52 +530369,70 @@ ${memoryLines.join("\n")}`
                 "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 REG61_BYPASS_TOOLS = /* @__PURE__ */ new Set([
+                ...REG61_EDIT_TOOLS,
+                // Escape hatches: explicitly allowed while gate is active so
+                // the agent can: search for unknown info (web_search), exit
+                // cleanly (task_complete), or escalate to human (ask_user).
+                // shell, file_read, todo_*, grep_search, list_directory are
+                // NOT in bypass — those are the exact patterns batch528/529
+                // agents used to ignore REG-61.
+                "web_search",
+                "task_complete",
+                "ask_user"
+              ]);
+              if (REG61_EDIT_TOOLS.has(tc.name) && this._reg61PerpetualGateActive) {
+                this._reg61PerpetualGateActive = false;
+                this.emit({
+                  type: "status",
+                  content: `REG-61 GATE CLEARED — '${tc.name}' satisfied REG-61 directive at turn ${turn}`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+              if (this._reg61PerpetualGateActive && !REG61_BYPASS_TOOLS.has(tc.name) && process.env["OA_DISABLE_REG61_COERCE"] !== "1") {
+                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]`,
+                  ``,
+                  `A REG-61 FIRST-EDIT NUDGE was issued earlier and has not yet been satisfied. The directive: your 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 to clear the directive:`,
+                  `  • 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 tools are also allowed while the directive is active (will not be blocked, will not clear the gate):`,
+                  `  • web_search    — for genuinely-unknown APIs / error strings`,
+                  `  • task_complete — to exit if you cannot make any progress`,
+                  `  • ask_user      — to escalate to human (if available)`,
+                  ``,
+                  `Until you issue a creative edit, ALL of these will be BLOCKED again on every turn: file_read, file_explore, list_directory, grep_search, shell, todo_write, todo_read, memory_read, memory_write, etc. Pick the smallest concrete change that moves work forward — even a partial stub or a single-line edit counts.`
+                ].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}; gate stays active until creative edit dispatches`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._tagSyntheticFailure({
+                  mode: "step_repetition",
+                  rationale: `REG-61 perpetual coercion block on '${tc.name}' — agent ignored FIRST-EDIT NUDGE`
+                });
+                return { tc, output: reg61BlockMsg };
               }
               const PROGRESS_GATE_BYPASS_TOOLS = /* @__PURE__ */ new Set([
                 "todo_write",

package/npm-shrinkwrap.json

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

package/package.json

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