open-agents-ai 0.187.574 → 0.187.576

package/dist/index.js

@@ -515299,26 +515299,10 @@ function summarizeMAST(tags) {
   }
   return { byMode, byCategory, total: tags.length };
 }
-var MAST_CATEGORY;
 var init_mast_tagger = __esm({
   "packages/orchestrator/dist/mast-tagger.js"() {
     "use strict";
     init_reflection();
-    MAST_CATEGORY = {
-      spec_disobedience: "specification_design",
-      step_repetition: "specification_design",
-      history_loss: "specification_design",
-      completion_unrecognized: "specification_design",
-      input_ignored: "inter_agent_misalignment",
-      proceeded_without_clarify: "inter_agent_misalignment",
-      conversation_reset: "inter_agent_misalignment",
-      reasoning_action_mismatch: "inter_agent_misalignment",
-      premature_termination: "task_verification_termination",
-      validation_skipped: "task_verification_termination",
-      shallow_check_accepted: "task_verification_termination",
-      premature_task_complete: "task_verification_termination",
-      other: "specification_design"
-    };
   }
 });
 
@@ -528102,15 +528086,16 @@ 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.
+      // REG-12: Progress advisory latch. When ≥6 file writes have happened
+      // without a todo_write call, this latch flips ON. While active, non-todo
+      // tool calls receive model-visible system guidance, but still execute.
+      // Released when todo_write fires successfully. Without this, the agent can
+      // re-emit the same plan a second time (plan-replay) and duplicate work.
       _progressGateActive = false;
+      // Consecutive advisory count. When the model ignores stale progress state,
+      // this counter increments. ≥2 triggers a system message escalation to break
+      // pattern-lock loops.
+      _consecutiveProgressAdvisories = 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
@@ -528340,19 +528325,12 @@ var init_agenticRunner = __esm({
       // explicitly excludes todo_write/memory_write/list_directory.
       _reg61CooldownUntilTurn = -1;
       // 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 task_complete /
-      // ask_user / explicit web-task escape hatches. Any creative edit dispatch
+      // persistent advisory until obeyed. Replaces BFC-61.E's one-shot nudge,
+      // which empirically warned but did not change behavior. When REG-61 fires,
+      // this latch goes true. While true, every non-bypass tool call receives
+      // model-visible guidance and still executes. 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
+      // grep_search, list_directory etc. are NOT in bypass because 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.
@@ -528360,15 +528338,18 @@ 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,
-      // 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.
+      // 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 injects guidance
+      // for NEW files (paths not yet edited) while still allowing the edit.
+      // 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
@@ -528893,15 +528874,12 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         });
       }
       /**
-       * DECOMP-2 PRE-dispatch enforcement check. Returns a synthetic block-message
-       * string when the gate should reject this dispatch; null to proceed normally.
+       * DECOMP-2 PRE-dispatch advisory check. Returns a model-visible guidance
+       * string when the file-spread advisory should surface; null to proceed
+       * without extra guidance. Callers inject the string as system guidance and
+       * then run the requested tool normally.
        *
-       * Caller logic differs between main-loop and brute-force dispatchers:
-       *   - Main loop returns the block as a synthetic { tc, output } result.
-       *   - Brute-force emits tool_result + pushes tool message + `continue`.
-       * Both invoke this method to compute the decision.
-       *
-       * Conditions for blocking:
+       * Conditions for surfacing guidance:
        *   - `_decomp2GateActive` is true (set by `_trackDecomp2` when threshold crossed)
        *   - tool is one of the 4 creative-edit tools
        *   - the path is NOT in `_decomp2MainContextFiles` (i.e. it's a NEW file)
@@ -528910,9 +528888,11 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
        * Already-touched paths pass through (current-module finishing work allowed).
        * sub_agent / task_complete / explicit web-task tools pass through (not creative-edit tools).
        */
-      _maybeDecomp2Block(tc, turn) {
+      _maybeDecomp2Advisory(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([
@@ -528931,9 +528911,9 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         const _moreFiles = this._decomp2MainContextFiles.size > 8 ? `
   ... +${this._decomp2MainContextFiles.size - 8} more` : "";
         const decomp2Msg = [
-          `[BLOCKED — DECOMP-2 main-context exhaustion]`,
+          `[DECOMP-2 advisory — main-context file spread]`,
           ``,
-          `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,36 +528929,40 @@ 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 keep this as advisory-only 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 ADVISORY — ${tc.name}('${_editPath}') at turn ${turn}; tool allowed, consider sub_agent for the next module`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        this._tagSyntheticFailure({
-          mode: "step_repetition",
-          rationale: `DECOMP-2 new-file block on '${tc.name}'(${_editPath}) — agent has spread edits across ${this._decomp2MainContextFiles.size} files without sub_agent`
-        });
         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
        * edits / sub_agent calls and check the gate-activation threshold.
        * Without this method on both paths, batch532 measured 14 distinct
        * files edited but DECOMP-2 never activated — because the main loop
-       * exited via blocked task_complete and all subsequent edits flowed
-       * through the brute-force dispatch which had no tracking.
+       * entered brute-force after task_complete review and all subsequent edits
+       * flowed through the brute-force dispatch which had no tracking.
        *
        * Side effects when fired:
        *   - On successful creative edit: adds path to `_decomp2MainContextFiles`,
-       *     possibly activates `_decomp2GateActive` (emits status).
+       *     possibly activates `_decomp2GateActive` (emits advisory status).
        *   - On successful sub_agent / priority_delegate / background_run:
-       *     increments counter, clears gate (emits status). Failed or malformed
-       *     delegation attempts do not satisfy the gate.
+       *     increments counter, clears advisory (emits status). Failed or
+       *     malformed delegation attempts do not satisfy the advisory.
        *
        * Pure post-dispatch: caller invokes AFTER the tool result is in hand,
        * regardless of which loop the dispatch happened in.
@@ -528990,12 +528974,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 ADVISORY 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 remain allowed, but sub_agent is recommended for the next module`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
@@ -529004,20 +528988,32 @@ 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({
               type: "status",
-              content: `DECOMP-2 GATE CLEARED — '${tc.name}' satisfied delegation directive at turn ${turn}`,
+              content: `DECOMP-2 ADVISORY CLEARED — '${tc.name}' satisfied delegation directive at turn ${turn}`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
@@ -529027,7 +529023,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
        * REG-66 Debug-Loop Detection (root-cause from batch535-midi, 2026-05-04).
        *
        * Empirical: midi run had 11x `npm run build 2>&1` + same 5 files re-read
-       * 5-6 times each + 22 BFC-61.G coercion BLOCKS — and ZERO of those blocks
+       * 5-6 times each + 22 BFC-61.G coercion advisories — and ZERO of those
        * resulted in a creative edit. The agent was rationally stuck: it
        * believed it needed to read more to debug, the build command kept
        * giving the same error, and the standard "issue an edit" directive
@@ -529040,7 +529036,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
        * different output. Without this signal we'd just keep telling the
        * agent to "make an edit" — which is exactly what it can't think of.
        *
-       * When detected, the BFC-61.G block message swaps to a PERTURB-strategy
+       * When detected, the BFC-61.G advisory message swaps to a PERTURB-strategy
        * directive: stop reading, change ONE thing in the most-likely-culprit
        * file even if you're uncertain, and let the new error signal guide
        * the next iteration. This is real human debugging strategy ("perturb
@@ -529177,27 +529173,6 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
        * name with objective evidence, complete remaining items in order, update the
        * checklist via todo_write, and only then call task_complete.
        */
-      /**
-       * REG-39c: tag a SYNTHETIC failure (FORCED PROGRESS BLOCK / observer
-       * block / budget exhausted). These paths return early from
-       * executeSingle BEFORE the main result-handling code, so the normal
-       * MAST tagging miss them. This helper lets each return-early site
-       * record a tag directly. Push-only — keeps the tag buffer bounded
-       * to 200 entries.
-       */
-      _tagSyntheticFailure(args) {
-        try {
-          this._mastTags.push({
-            mode: args.mode,
-            category: MAST_CATEGORY[args.mode],
-            rationale: args.rationale
-          });
-          if (this._mastTags.length > 200) {
-            this._mastTags = this._mastTags.slice(-200);
-          }
-        } catch {
-        }
-      }
       /**
        * REG-39b: emit a MAST taxonomy summary as a status event. Called both
        * mid-run (every N turns, so SIGTERM kills don't lose the data) and at
@@ -531097,9 +531072,14 @@ Respond with your assessment, then take action.`;
         this._fileWriteTimestamps = [];
         this._aborting = false;
         this._reg61CooldownUntilTurn = -1;
+        this._writesSinceLastTodoWrite = 0;
+        this._progressGateActive = false;
+        this._consecutiveProgressAdvisories = 0;
         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;
@@ -533396,24 +533376,9 @@ ${memoryLines.join("\n")}`
                 });
               }
               {
-                const _decomp2Block = this._maybeDecomp2Block(tc, turn);
-                if (_decomp2Block) {
-                  this.emit({
-                    type: "tool_call",
-                    toolName: tc.name,
-                    toolArgs: tc.arguments,
-                    turn,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                  });
-                  this.emit({
-                    type: "tool_result",
-                    toolName: tc.name,
-                    success: false,
-                    content: _decomp2Block.slice(0, 120),
-                    turn,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                  });
-                  return { tc, output: _decomp2Block };
+                const _decomp2Advisory = this._maybeDecomp2Advisory(tc, turn);
+                if (_decomp2Advisory) {
+                  pushSoftInjection("system", _decomp2Advisory);
                 }
               }
               const PROGRESS_GATE_BYPASS_TOOLS = /* @__PURE__ */ new Set([
@@ -533425,74 +533390,55 @@ ${memoryLines.join("\n")}`
                 // 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 [path11, info] of this._worldFacts.files) {
                   if ((info.writeCount ?? 0) > 0 && (info.lastWriteTurn ?? -1) >= 0 && turn - (info.lastWriteTurn ?? 0) <= 8) {
                     recentWrites.push({ path: path11, turn: info.lastWriteTurn ?? 0 });
                   }
                 }
+                this._consecutiveProgressAdvisories++;
                 recentWrites.sort((a2, b) => b.turn - a2.turn);
                 const showWrites = recentWrites.slice(0, 16);
+                const isRepeat = this._consecutiveProgressAdvisories >= 2;
                 const gateMsg = [
-                  `[PROGRESS GATE — call todo_write FIRST before any other tool]`,
+                  `[PROGRESS ADVISORY — todo update recommended]`,
                   ``,
-                  `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: The requested tool is still allowed. Update todos soon so progress state stays accurate.`,
+                  `ACTION RECOMMENDED: Call todo_write with updated progress after this tool call if the recent writes satisfy todo items.`,
+                  isRepeat ? `
+[ESCALATION: This is advisory #${this._consecutiveProgressAdvisories}. You are continuing without todo_write; progress replay risk is increasing.]` : "",
                   ``,
                   `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.`
                 ].filter(Boolean).join("\n");
+                pushSoftInjection("system", gateMsg);
                 this.emit({
-                  type: "tool_result",
+                  type: "status",
                   toolName: tc.name,
-                  success: false,
-                  content: gateMsg.slice(0, 120),
+                  content: `PROGRESS ADVISORY — ${this._writesSinceLastTodoWrite} writes since todo_write; '${tc.name}' allowed`,
                   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);
               if (budgetRemaining !== void 0 && !_isCachedHit) {
                 if (budgetRemaining <= 0) {
+                  const budgetMsg = `[BUDGET ADVISORY] You have used all ${toolBudgets[tc.name]} recommended ${tc.name} calls for the current phase. The requested tool call is still allowed, but repeated use may be low-value. If your todo list shows more phases pending: mark the current phase completed via todo_write so a new budget allowance kicks in. If all phases are done: call task_complete with your final summary.`;
+                  pushSoftInjection("system", budgetMsg);
                   this.emit({
-                    type: "tool_call",
-                    toolName: tc.name,
-                    toolArgs: tc.arguments,
-                    turn,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                  });
-                  const budgetMsg = `[BUDGET EXHAUSTED] You have used all ${toolBudgets[tc.name]} allowed ${tc.name} calls for the current phase. You ALREADY have enough information from previous calls. DO NOT try to call ${tc.name} again — it will be blocked. If your todo list shows more phases pending: mark the current phase completed via todo_write so a new budget allowance kicks in. If all phases are done: call task_complete with your final summary.`;
-                  this.emit({
-                    type: "tool_result",
-                    toolName: tc.name,
-                    success: false,
-                    content: budgetMsg.slice(0, 120),
-                    turn,
+                    type: "status",
+                    content: `BUDGET ADVISORY — ${tc.name} exceeded recommended per-phase budget; tool allowed`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                  this._tagSyntheticFailure({
-                    mode: "step_repetition",
-                    rationale: `${tc.name} exhausted per-phase budget of ${toolBudgets[tc.name]}`
-                  });
-                  return { tc, output: budgetMsg };
+                } else {
+                  toolCallBudget.set(tc.name, budgetRemaining - 1);
                 }
-                toolCallBudget.set(tc.name, budgetRemaining - 1);
               }
               const toolFingerprint = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
               const baseIsReadLike = ![
@@ -533577,29 +533523,15 @@ ${memoryLines.join("\n")}`
                 observerRedundantBlock
               });
               if (criticDecision.decision === "observer_block") {
-                this.emit({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  toolArgs: tc.arguments,
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                const blockMsg = criticDecision.cachedResult ? `[BLOCKED — this tool+args already succeeded. Re-served from cache:]
+                const advisoryMsg = criticDecision.cachedResult ? `[DUPLICATE-CALL ADVISORY — this tool+args already succeeded. Prior result preview:]
 
-${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confirmed this tool already succeeded with these arguments on a prior turn. Do NOT re-run. Use your prior findings to proceed.]`;
+${criticDecision.cachedResult.slice(0, 500)}` : `[DUPLICATE-CALL ADVISORY — the observer confirmed this tool already succeeded with these arguments on a prior turn. The call is still allowed, but using prior findings may be faster.]`;
+                pushSoftInjection("system", advisoryMsg);
                 this.emit({
-                  type: "tool_result",
-                  toolName: tc.name,
-                  success: true,
-                  content: blockMsg.slice(0, 100),
-                  turn,
+                  type: "status",
+                  content: `DUPLICATE-CALL ADVISORY — ${tc.name} allowed despite observer redundancy`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                this._tagSyntheticFailure({
-                  mode: "step_repetition",
-                  rationale: `observer-block on ${tc.name} fingerprint flagged redundant`
-                });
-                return { tc, output: blockMsg };
               }
               if (criticDecision.decision === "force_progress_block") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
@@ -533608,26 +533540,12 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                   recentToolResults.delete(toolFingerprint);
                   recentToolResults.set(toolFingerprint, _existingFp);
                 }
+                pushSoftInjection("system", criticDecision.blockMessage.replace(/\[FORCED PROGRESS BLOCK[^\]]*\]|\[BLOCKED[^\]]*\]/gi, "[REPETITION ADVISORY]"));
                 this.emit({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  toolArgs: tc.arguments,
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                this.emit({
-                  type: "tool_result",
-                  toolName: tc.name,
-                  success: false,
-                  content: criticDecision.blockMessage.slice(0, 120),
-                  turn,
+                  type: "status",
+                  content: `REPETITION ADVISORY — ${tc.name} repeated ${criticDecision.hitNumber} times; tool allowed`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                this._tagSyntheticFailure({
-                  mode: "step_repetition",
-                  rationale: `force_progress_block on ${tc.name} after ${criticDecision.hitNumber} identical calls`
-                });
-                return { tc, output: criticDecision.blockMessage };
               }
               if (criticDecision.decision === "serve_cached") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
@@ -533636,30 +533554,20 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                   recentToolResults.delete(toolFingerprint);
                   recentToolResults.set(toolFingerprint, _existingFp);
                 }
-                this.emit({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  toolArgs: tc.arguments,
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                const header = criticDecision.compacted ? `[RE-SERVED FROM CACHE — the original result was compacted from context. Here is the data again. No need to call this tool again.]
+                const header = criticDecision.compacted ? `[CACHE ADVISORY — the original result was compacted from context. Prior data preview follows; the tool call is still allowed.]
 
-` : `[DUPLICATE CALL #${criticDecision.hitNumber} — you already called ${tc.name} with these exact arguments. The result is identical. Do NOT call this again. Use the data you already have to make progress. One more identical call will trigger a hard progress block.]
+` : `[DUPLICATE CALL #${criticDecision.hitNumber} — you already called ${tc.name} with these exact arguments. The result may be identical. The tool call is still allowed, but using existing data may be faster.]
 
 `;
                 const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
 ... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
                 const dedupOutput = header + truncatedCache;
+                pushSoftInjection("system", dedupOutput);
                 this.emit({
-                  type: "tool_result",
-                  toolName: tc.name,
-                  success: true,
-                  content: header.slice(0, 100),
-                  turn,
+                  type: "status",
+                  content: `CACHE ADVISORY — ${tc.name} duplicate call #${criticDecision.hitNumber}; tool allowed`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                return { tc, output: dedupOutput };
               }
               this.emit({
                 type: "tool_call",
@@ -533709,6 +533617,18 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                   const violations = checkConstraints(tc.name, tc.arguments);
                   const blockViolations = violations.filter((v) => v.constraint.action === "block");
                   if (blockViolations.length > 0) {
+                    const warning = formatViolationWarning(blockViolations);
+                    pushSoftInjection("system", `[CONSTRAINT ADVISORY]
+${warning}
+The tool call is still allowed by the no-hard-block policy. Treat this as risk guidance, not a runtime denial.`);
+                    this.emit({
+                      type: "status",
+                      content: `Constraint advisory: ${blockViolations[0].constraint.message}`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    pendingConstraintWarnings.push(warning);
+                  }
+                  if (process.env["OA_ENABLE_HARD_TOOL_BLOCKS"] === "1" && blockViolations.length > 0) {
                     result = {
                       success: false,
                       output: "",
@@ -533732,6 +533652,16 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                     }
                     const hookCheck = this._hookManager.runPreToolUse(tc.name, tc.arguments, this._sessionId);
                     if (!hookCheck.allowed) {
+                      pushSoftInjection("system", `[HOOK ADVISORY]
+Tool "${tc.name}" matched a pre-tool hook warning: ${hookCheck.reason ?? "hook denied"}.
+The tool call is still allowed by the no-hard-block policy. Treat this as guidance and proceed deliberately.`);
+                      this.emit({
+                        type: "status",
+                        content: `Hook advisory for ${tc.name}: ${hookCheck.reason ?? "hook denied"}. Tool allowed by no-hard-block policy.`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                    if (process.env["OA_ENABLE_HARD_TOOL_BLOCKS"] === "1" && !hookCheck.allowed) {
                       result = {
                         success: false,
                         output: "",
@@ -533888,7 +533818,7 @@ Respond with EXACTLY this structure before your next tool call:
                 this._reg61PerpetualGateActive = false;
                 this.emit({
                   type: "status",
-                  content: `REG-61 GATE CLEARED — '${tc.name}' landed real file mutation at turn ${turn}`,
+                  content: `REG-61 ADVISORY CLEARED — '${tc.name}' landed real file mutation at turn ${turn}`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
               }
@@ -533923,7 +533853,7 @@ Respond with EXACTLY this structure before your next tool call:
                       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`,
+                        content: `Progress advisory engaged at ${this._writesSinceLastTodoWrite} writes without todo_write — non-todo tools remain allowed, todo update recommended`,
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
                       });
                     }
@@ -533939,6 +533869,7 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                   this._writesSinceLastTodoWrite = 0;
                   this._progressGateActive = false;
+                  this._consecutiveProgressAdvisories = 0;
                 }
                 if (tc.name === "file_read") {
                   const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "");
@@ -534947,6 +534878,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._consecutiveProgressAdvisories >= 2 && this._progressGateActive) {
+                    messages2.push({
+                      role: "system",
+                      content: `[PROGRESS ADVISORY ESCALATION] You have made ${this._consecutiveProgressAdvisories} consecutive tool calls while progress tracking is stale. The last tool was allowed to run, but your NEXT call should be todo_write(todos=[...]) with updated progress so the plan and completed work stay synchronized.`
+                    });
+                  }
                   if (matchTc.name === "task_complete") {
                     const open2 = this.getOpenTodoItems();
                     if (open2.length > 0) {
@@ -534954,28 +534891,32 @@ ${sr.result.output}`;
                       messages2.push({ role: "system", content: guard });
                       this.emit({
                         type: "status",
-                        content: `task_complete intercepted — ${open2.length} open todo(s) remain`,
+                        content: `task_complete advisory — ${open2.length} open todo(s) remain; completion allowed`,
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
                       });
-                    } else {
-                      const _bp1 = await this._runBackwardPassReview(turn);
-                      if (_bp1 && !_bp1.proceed && _bp1.feedback) {
-                        messages2.push({ role: "system", content: _bp1.feedback });
-                      } else {
-                        completed = true;
-                        summary = extractTaskCompleteSummary(matchTc.arguments);
-                        if (summary && !this._assistantTextEmitted) {
-                          this.emit({
-                            type: "assistant_text",
-                            content: summary,
-                            turn,
-                            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                          });
-                          this._assistantTextEmitted = true;
-                        }
-                        break;
-                      }
                     }
+                    const _bp1 = await this._runBackwardPassReview(turn);
+                    if (_bp1 && !_bp1.proceed && _bp1.feedback) {
+                      messages2.push({ role: "system", content: `[COMPLETION REVIEW ADVISORY]
+${_bp1.feedback}` });
+                      this.emit({
+                        type: "status",
+                        content: "completion review advisory surfaced; task_complete allowed",
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                    completed = true;
+                    summary = extractTaskCompleteSummary(matchTc.arguments);
+                    if (summary && !this._assistantTextEmitted) {
+                      this.emit({
+                        type: "assistant_text",
+                        content: summary,
+                        turn,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                      this._assistantTextEmitted = true;
+                    }
+                    break;
                   }
                 }
               }
@@ -534987,6 +534928,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._consecutiveProgressAdvisories >= 2 && this._progressGateActive) {
+                      messages2.push({
+                        role: "system",
+                        content: `[PROGRESS ADVISORY ESCALATION] You have made ${this._consecutiveProgressAdvisories} consecutive tool calls while progress tracking is stale. The last tool was allowed to run, but your NEXT call should be todo_write(todos=[...]) with updated progress so the plan and completed work stay synchronized.`
+                      });
+                    }
                     if (r2.tc.name === "task_complete") {
                       const open2 = this.getOpenTodoItems();
                       if (open2.length > 0) {
@@ -534994,28 +534941,32 @@ ${sr.result.output}`;
                         messages2.push({ role: "system", content: guard });
                         this.emit({
                           type: "status",
-                          content: `task_complete intercepted — ${open2.length} open todo(s) remain`,
+                          content: `task_complete advisory — ${open2.length} open todo(s) remain; completion allowed`,
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
                         });
-                      } else {
-                        const _bp2 = await this._runBackwardPassReview(turn);
-                        if (_bp2 && !_bp2.proceed && _bp2.feedback) {
-                          messages2.push({ role: "system", content: _bp2.feedback });
-                        } else {
-                          completed = true;
-                          summary = extractTaskCompleteSummary(r2.tc.arguments);
-                          if (summary && !this._assistantTextEmitted) {
-                            this.emit({
-                              type: "assistant_text",
-                              content: summary,
-                              turn,
-                              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                            });
-                            this._assistantTextEmitted = true;
-                          }
-                          break;
-                        }
                       }
+                      const _bp2 = await this._runBackwardPassReview(turn);
+                      if (_bp2 && !_bp2.proceed && _bp2.feedback) {
+                        messages2.push({ role: "system", content: `[COMPLETION REVIEW ADVISORY]
+${_bp2.feedback}` });
+                        this.emit({
+                          type: "status",
+                          content: "completion review advisory surfaced; task_complete allowed",
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                      }
+                      completed = true;
+                      summary = extractTaskCompleteSummary(r2.tc.arguments);
+                      if (summary && !this._assistantTextEmitted) {
+                        this.emit({
+                          type: "assistant_text",
+                          content: summary,
+                          turn,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                        this._assistantTextEmitted = true;
+                      }
+                      break;
                     }
                   }
                 }
@@ -535069,36 +535020,40 @@ ${sr.result.output}`;
                         messages2.push({ role: "system", content: guard });
                         this.emit({
                           type: "status",
-                          content: `task_complete intercepted — ${open2.length} open todo(s) remain`,
+                          content: `task_complete advisory — ${open2.length} open todo(s) remain; completion allowed`,
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
                         });
-                      } else {
-                        const _bp3 = await this._runBackwardPassReview(turn);
-                        if (_bp3 && !_bp3.proceed && _bp3.feedback) {
-                          messages2.push({ role: "system", content: _bp3.feedback });
-                        } else {
-                          completed = true;
-                          summary = extractTaskCompleteSummary(r2.tc.arguments);
-                          for (const tool of this.tools.values()) {
-                            if (tool.cleanup) {
-                              try {
-                                await tool.cleanup();
-                              } catch {
-                              }
-                            }
-                          }
-                          if (summary && !this._assistantTextEmitted) {
-                            this.emit({
-                              type: "assistant_text",
-                              content: summary,
-                              turn,
-                              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                            });
-                            this._assistantTextEmitted = true;
+                      }
+                      const _bp3 = await this._runBackwardPassReview(turn);
+                      if (_bp3 && !_bp3.proceed && _bp3.feedback) {
+                        messages2.push({ role: "system", content: `[COMPLETION REVIEW ADVISORY]
+${_bp3.feedback}` });
+                        this.emit({
+                          type: "status",
+                          content: "completion review advisory surfaced; task_complete allowed",
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                      }
+                      completed = true;
+                      summary = extractTaskCompleteSummary(r2.tc.arguments);
+                      for (const tool of this.tools.values()) {
+                        if (tool.cleanup) {
+                          try {
+                            await tool.cleanup();
+                          } catch {
                           }
-                          break;
                         }
                       }
+                      if (summary && !this._assistantTextEmitted) {
+                        this.emit({
+                          type: "assistant_text",
+                          content: summary,
+                          turn,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                        this._assistantTextEmitted = true;
+                      }
+                      break;
                     }
                   }
                 }
@@ -535711,18 +535666,9 @@ Integrate this guidance into your current approach. Continue working on the task
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                const _decomp2BFBlock = this._maybeDecomp2Block(tc, turn);
-                if (_decomp2BFBlock) {
-                  this.emit({
-                    type: "tool_result",
-                    toolName: tc.name,
-                    content: _decomp2BFBlock.slice(0, 200),
-                    success: false,
-                    turn,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                  });
-                  messages2.push(this.buildToolMessage(_decomp2BFBlock, tc.id, tc.name));
-                  continue;
+                const _decomp2BFAdvisory = this._maybeDecomp2Advisory(tc, turn);
+                if (_decomp2BFAdvisory) {
+                  messages2.push({ role: "system", content: _decomp2BFAdvisory });
                 }
                 const tool = this.tools.get(tc.name);
                 let result;
@@ -535823,28 +535769,32 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                     messages2.push({ role: "system", content: guard });
                     this.emit({
                       type: "status",
-                      content: `task_complete intercepted — ${open2.length} open todo(s) remain`,
+                      content: `task_complete advisory — ${open2.length} open todo(s) remain; completion allowed`,
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
-                  } else {
-                    const _bp4 = await this._runBackwardPassReview(turn);
-                    if (_bp4 && !_bp4.proceed && _bp4.feedback) {
-                      messages2.push({ role: "system", content: _bp4.feedback });
-                      continue;
-                    }
-                    completed = true;
-                    summary = extractTaskCompleteSummary(tc.arguments);
-                    if (summary && !this._assistantTextEmitted) {
-                      this.emit({
-                        type: "assistant_text",
-                        content: summary,
-                        turn,
-                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                      });
-                      this._assistantTextEmitted = true;
-                    }
-                    break;
                   }
+                  const _bp4 = await this._runBackwardPassReview(turn);
+                  if (_bp4 && !_bp4.proceed && _bp4.feedback) {
+                    messages2.push({ role: "system", content: `[COMPLETION REVIEW ADVISORY]
+${_bp4.feedback}` });
+                    this.emit({
+                      type: "status",
+                      content: "completion review advisory surfaced; task_complete allowed",
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                  completed = true;
+                  summary = extractTaskCompleteSummary(tc.arguments);
+                  if (summary && !this._assistantTextEmitted) {
+                    this.emit({
+                      type: "assistant_text",
+                      content: summary,
+                      turn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    this._assistantTextEmitted = true;
+                  }
+                  break;
                 }
               }
               if (completed)
@@ -535872,14 +535822,13 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   messages2.push({ role: "system", content: guard });
                   this.emit({
                     type: "status",
-                    content: `task_complete text detected but intercepted — ${open2.length} open todo(s) remain`,
+                    content: `task_complete text advisory — ${open2.length} open todo(s) remain; completion allowed`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                } else {
-                  completed = true;
-                  summary = content;
-                  break;
                 }
+                completed = true;
+                summary = content;
+                break;
               }
               const finalVarMatch = content.match(/FINAL_VAR\s*\(\s*["']?(\w+)["']?\s*\)/);
               if (finalVarMatch && this.options.finalVarResolver) {
@@ -614072,7 +614021,7 @@ function createTaskCompleteTool(modelTier) {
   const summaryDesc = modelTier === "small" || modelTier === "medium" ? "Your complete response to the user. For questions/chat: put your FULL answer here (this is what the user will see). For coding tasks: brief summary of what was accomplished." : "Brief summary of what was accomplished";
   return {
     name: "task_complete",
-    description: "Signal that the task is complete. GUARDED: cannot fire while the active todo list (todo_write) has pending, in_progress, or blocked items. If you're truly done, first call todo_write to mark every remaining item completed. If you're not done, continue working down the list and call this only after the last item flips to completed.",
+    description: "Signal that the task is complete. ADVISORY: if active todos, interactive sessions, or build checks indicate risk, the tool result will include model-visible guidance, but the tool is not hard-blocked.",
     parameters: {
       type: "object",
       properties: {
@@ -614081,11 +614030,14 @@ function createTaskCompleteTool(modelTier) {
       required: ["summary"]
     },
     async execute(args) {
+      const summary = args["summary"] || "Task completed.";
       if (_interactiveSessionActive) {
         return {
-          success: false,
-          output: `SESSION STILL ACTIVE. Call your next interaction tool NOW. Do NOT produce text — call a tool immediately to continue the session.`,
-          error: `task_complete BLOCKED — interactive session still active. ${_interactiveSessionReason} You MUST continue the interaction loop until the session ends. Do NOT call task_complete until you receive a termination signal (e.g. "ended", "disconnected", "closed", SESSION_ACTIVE=false). YOUR NEXT ACTION: call the listening/polling tool to continue the session.`
+          success: true,
+          output: `[TASK_COMPLETE ADVISORY — interactive session still active]
+${_interactiveSessionReason} You should continue the interaction loop until the session ends (e.g. "ended", "disconnected", "closed", SESSION_ACTIVE=false). The completion is allowed by no-hard-block policy.
+
+${summary}`
         };
       }
       try {
@@ -614111,14 +614063,17 @@ Respond concisely in this shape:
   - verify: [{ name: "<exact item text>", completed: true|false, evidence: "<objective proof>" }, ...]
   - next: "what you will do next OR the exact todo_write(...) call to update statuses"`;
             return {
-              success: false,
-              output: "",
-              error: `task_complete BLOCKED — ${incomplete.length} todo item(s) still incomplete.
+              success: true,
+              output: `[TASK_COMPLETE ADVISORY — ${incomplete.length} todo item(s) still incomplete]
 
 Incomplete items:
 ${incompleteList}${more}
 
-` + guidance
+${guidance}
+
+Completion is allowed by no-hard-block policy.
+
+${summary}`
             };
           }
           try {
@@ -614128,7 +614083,6 @@ ${incompleteList}${more}
         }
       } catch {
       }
-      const summary = args["summary"] || "Task completed.";
       const buildGuardSkip = process.env["OA_DISABLE_TASK_COMPLETE_BUILD_GUARD"] === "1" || /^\s*BLOCKED\b/i.test(summary);
       if (!buildGuardSkip) {
         try {
@@ -614152,16 +614106,15 @@ ${incompleteList}${more}
               } catch (e2) {
                 const out = ((e2?.stdout || "") + (e2?.stderr || "")).toString().slice(0, 2e3);
                 return {
-                  success: false,
-                  output: "",
-                  error: `task_complete BLOCKED — \`npm run ${checkScript}\` is failing in ${cwd4}.
+                  success: true,
+                  output: `[TASK_COMPLETE ADVISORY — \`npm run ${checkScript}\` is failing in ${cwd4}]
 
 Error output (last 2KB):
 ${out || "<empty stdout/stderr — likely timeout or non-zero exit>"}
 
-Fix the build errors before calling task_complete. If you genuinely cannot fix it (e.g. missing tool, env issue), call task_complete with a summary that STARTS with "BLOCKED: " and explains why.
+Recommended: fix the build errors before considering the work done. Completion is still allowed by no-hard-block policy.
 
-Bypass for special cases: set env OA_DISABLE_TASK_COMPLETE_BUILD_GUARD=1 (not recommended).`
+${summary}`
                 };
               }
             }

package/npm-shrinkwrap.json

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