open-agents-ai 0.187.562 → 0.187.564

package/dist/index.js

@@ -532536,8 +532536,9 @@ ${memoryLines.join("\n")}`
                   });
                   for (const _old of _sorted.slice(0, 2)) {
                     const _oldId = _old.id;
-                    if (_oldId) {
-                      this._evictCompletedTodoMessages(0, turn, _oldId, _old.content, compacted);
+                    if (_oldId && this._todoInProgressTurn.has(_oldId)) {
+                      const _st = this._todoInProgressTurn.get(_oldId);
+                      this._evictCompletedTodoMessages(_st, turn, _oldId, _old.content, compacted);
                     }
                   }
                 }
@@ -533019,99 +533020,50 @@ ${memoryLines.join("\n")}`
               ]);
               const REG61_BYPASS_TOOLS = /* @__PURE__ */ new Set([
                 ...REG61_EDIT_TOOLS,
-                // Escape hatches: explicitly allowed while gate is active so
-                // the agent can exit cleanly (task_complete), escalate to human
-                // (ask_user), or complete an explicit web task without deadlock.
-                // 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",
-                // DECOMP-1: sub-agent dispatch is productive work (it spawns
-                // a focused-context implementation worker). Block-listing
-                // sub_agent here would defeat the spec-decomposition pattern
-                // — agents would be forced into main-context edits even when
-                // delegation is the right move. sub_agent calls do NOT clear
-                // the gate (we want the agent to also produce direct edits
-                // for orchestration glue / integration), but they're allowed
-                // through.
                 "sub_agent",
                 "priority_delegate",
                 "background_run"
               ]);
               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 _dbgLoop = this._detectDebugLoop(toolCallLog);
                 const _debugLoopSampleSafe = (_dbgLoop.repeatedSample ?? "").slice(0, 120);
                 const _localFailureNudge = this._renderLocalFailureNudge(turn);
-                const reg61BlockMsg = _dbgLoop.detected ? [
-                  `[BLOCKED — REG-61 directive in effect — REG-66 DEBUG-LOOP detected]`,
+                const reg61SteerMsg = _dbgLoop.detected ? [
+                  `[REG-61 directive active — REG-66 DEBUG-LOOP detected]`,
                   ``,
-                  `Pattern: ${_dbgLoop.kind === "shell" ? "shell command" : "file"} "${_debugLoopSampleSafe}" was used ${_dbgLoop.count}× in the trailing window with ZERO creative edits landing. You are stuck in a debug loop where re-running / re-reading is producing no new information.`,
+                  `Pattern: ${_dbgLoop.kind === "shell" ? "shell command" : "file"} "${_debugLoopSampleSafe}" was used ${_dbgLoop.count}× in the trailing window with ZERO creative edits landing. You appear stuck in a debug loop where re-running / re-reading is producing no new information.`,
                   ``,
-                  `STOP DEBUGGING. PERTURB.`,
+                  `Consider PERTURBING: make a speculative edit to get a NEW error signal.`,
                   ``,
-                  `Strategy when stuck like this (real human debuggers do this):`,
-                  `  1. Pick the source file most likely implicated by the recurring failure (probably in src/, the one most-imported by failing tests).`,
+                  `Strategy:`,
+                  `  1. Pick the source file most likely implicated by the recurring failure.`,
                   `  2. Pick ONE plausible cause — most-recently-modified line, most-complex function, most-likely-misnamed import, most-likely off-by-one.`,
                   `  3. Make a SPECULATIVE edit that changes that thing — even if you are NOT certain it'll fix the bug. The point is to get a NEW error signal that disambiguates.`,
-                  `  4. Re-run the failing command. If the error CHANGED, you've learned something. If it's identical, you've ruled out one hypothesis.`,
-                  ``,
-                  `This is NOT random guessing — it's targeted hypothesis falsification. Reading the same files 5+ times has already proven uninformative; only a state change will move the system.`,
-                  ``,
-                  `Issue EXACTLY ONE of: file_write / file_edit / batch_edit / file_patch on a single concrete change. The edit must actually change disk state; dry-runs and no-ops do not clear this directive.`,
+                  `  4. Re-run the failing command. If the error CHANGED, you've learned something.`,
                   ``,
-                  _localFailureNudge,
-                  ``,
-                  `Allowed exits (will not be blocked but will not clear the directive either):`,
-                  `  * task_complete - exit if you genuinely cannot identify any plausible local perturbation`,
-                  `  * ask_user      - escalate to human (if available)`,
-                  ``,
-                  `Once you make a real edit, the directive clears and you'll see the new test result.`
+                  `This tool call was ALLOWED through, but the edit directive remains active.`
                 ].join("\n") : [
-                  `[BLOCKED — REG-61 directive in effect]`,
+                  `[REG-61 directive active]`,
                   ``,
-                  `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.`,
+                  `A REG-61 FIRST-EDIT NUDGE was issued earlier and has not yet been satisfied. The directive asks you to prioritize a creative edit. You issued '${tc.name}' instead, which is a read/explore/shell call.`,
                   ``,
-                  `Issue EXACTLY ONE of these to clear the directive:`,
+                  `This call was ALLOWED through (needed context should never be blocked), but try to make a creative edit next:`,
                   `  • 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 version-checked line-range patch`,
                   ``,
-                  _localFailureNudge,
-                  ``,
-                  `These exits are also allowed while the directive is active (will not be blocked, will not clear the gate):`,
-                  `  * task_complete - to exit if you cannot make any local progress`,
-                  `  * ask_user      - to escalate to human (if available)`,
-                  ``,
-                  `Until you issue a creative edit that actually changes disk, 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.`
+                  _localFailureNudge
                 ].join("\n");
-                this.emit({
-                  type: "tool_result",
-                  toolName: tc.name,
-                  success: false,
-                  content: reg61BlockMsg.slice(0, 120),
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
+                pushSoftInjection("system", reg61SteerMsg);
                 this.emit({
                   type: "status",
-                  content: `REG-61 COERCION BLOCK — rejected '${tc.name}' at turn ${turn}; gate stays active until creative edit dispatches${_dbgLoop.detected ? `; REG-66 debug-loop variant (${_dbgLoop.kind} "${_debugLoopSampleSafe.slice(0, 60)}" ${_dbgLoop.count}×)` : ""}`,
+                  content: `REG-61 STEER — nudge injected for '${tc.name}' at turn ${turn}; tool ALLOWED; gate stays active${_dbgLoop.detected ? `; REG-66 debug-loop variant (${_dbgLoop.kind} "${_debugLoopSampleSafe.slice(0, 60)}" ${_dbgLoop.count}×)` : ""}`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                this._tagSyntheticFailure({
-                  mode: "step_repetition",
-                  rationale: `REG-61 perpetual coercion block on '${tc.name}' — agent ignored FIRST-EDIT NUDGE${_dbgLoop.detected ? " (debug-loop variant)" : ""}`
-                });
-                return { tc, output: reg61BlockMsg };
               }
               {
                 const _decomp2Block = this._maybeDecomp2Block(tc, turn);

package/npm-shrinkwrap.json

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

package/package.json

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