omnius 1.0.480 → 1.0.482

package/dist/index.js

@@ -576512,16 +576512,16 @@ var init_focusSupervisor = __esm({
           if (prior.requiredNextAction === "read_authoritative_target" && input.cachedResult && (input.duplicateHitCount ?? 0) >= Math.max(1, this.repeatGateMax - 1)) {
             const deadlockDirective = this.setDirective({
               turn: input.turn,
-              state: "terminal_incomplete",
-              reason: `read target is repeat-gated (${input.duplicateHitCount} hits); directive ${prior.id} cannot be satisfied without fresh reads; report blocked with evidence`,
-              requiredNextAction: "report_incomplete",
+              state: "forced_replan",
+              reason: `read target is repeat-gated (${input.duplicateHitCount} hits); directive ${prior.id} cannot be satisfied without fresh reads; TRIAGE instead of stalling — pivot approach or web_search the blocker`,
+              requiredNextAction: "creative_pivot_or_research",
               forbiddenActionFamilies: []
             });
             return this.block(deadlockDirective, [
-              "[FOCUS SUPERVISOR: DEADLOCK]",
+              "[FOCUS SUPERVISOR: DEADLOCK — TRIAGE]",
               `Directive ${prior.id} (${prior.requiredNextAction}) requires reading evidence that is repeat-gated (${input.duplicateHitCount} identical reads).`,
-              "The model cannot satisfy this directive because the repeat gate blocks re-reads, and other actions are forbidden by the current directive.",
-              "Report incomplete/blocked with the concrete evidence you have, and describe what additional access would break the deadlock."
+              "This exact path is blocked, but the task is NOT over. Do not report incomplete.",
+              "TRIAGE: pivot to a fundamentally different approach, or web_search the exact blocker to find another route, then act on it."
             ].join("\n"), false);
           }
           if (strict && prior.ignoredCount >= 1) {
@@ -576533,9 +576533,11 @@ var init_focusSupervisor = __esm({
             }
             const directive = this.setDirective({
               turn: input.turn,
-              state: terminal ? "terminal_incomplete" : ignoredManyTimes ? "verify_or_block" : "single_next_action",
-              reason: terminal ? `model ignored ${this.ignoredDirectiveStreak} focus directives with no satisfying recovery action; report incomplete with the blocker and evidence` : ignoredManyTimes ? `model ignored ${this.ignoredDirectiveStreak} focus directives; take the required recovery action before trying another variant` : `model ignored prior directive ${prior.id}; ${prior.reason}`,
-              requiredNextAction: terminal ? "report_incomplete" : prior.requiredNextAction,
+              // TRIAGE replaces terminal: after many ignored directives the model is
+              // stuck on ONE approach — steer it to pivot/research, never to abandon.
+              state: terminal ? "forced_replan" : ignoredManyTimes ? "verify_or_block" : "single_next_action",
+              reason: terminal ? `model ignored ${this.ignoredDirectiveStreak} focus directives; this approach is exhausted — TRIAGE: pivot to a fundamentally different method or web_search the exact blocker, do NOT report incomplete` : ignoredManyTimes ? `model ignored ${this.ignoredDirectiveStreak} focus directives; take the required recovery action before trying another variant` : `model ignored prior directive ${prior.id}; ${prior.reason}`,
+              requiredNextAction: terminal ? "creative_pivot_or_research" : prior.requiredNextAction,
               forbiddenActionFamilies: uniqueLimited(accumulatedFamilies)
             });
             this.lastIgnoredDirectiveTurn = input.turn;
@@ -576544,7 +576546,7 @@ var init_focusSupervisor = __esm({
               `Required next action: ${directive.requiredNextAction}.`,
               `Blocked action family: ${family}.`,
               actionReasonSummary(input.actionReason),
-              directive.requiredNextAction === "report_incomplete" ? "Stop trying tool variants. Report incomplete/blocked with the concrete evidence." : "Take the required next action before trying another variant."
+              directive.requiredNextAction === "creative_pivot_or_research" ? "Stop trying variants of what failed. The task is NOT over — pivot to a fundamentally different approach or web_search the exact blocker, then act." : "Take the required next action before trying another variant."
             ].filter(Boolean).join("\n"), false);
           }
         }
@@ -576759,14 +576761,21 @@ var init_focusSupervisor = __esm({
           forbiddenActionFamilies: ["task_complete"]
         });
       }
+      /**
+       * TRIAGE (replaces terminal-incomplete). A task is never abandoned. At the
+       * inflection where the old design would report incomplete, steer the model to
+       * a creative pivot or online research instead: the trajectory that failed is
+       * dead, but the TASK is not. The turn cap remains the ultimate backstop, so
+       * this cannot loop forever. Kept the method name so all callers are unchanged.
+       */
       markTerminalIncomplete(reason, turn) {
         if (!this.enabled)
           return;
         this.setDirective({
           turn,
-          state: "terminal_incomplete",
-          reason,
-          requiredNextAction: "report_incomplete",
+          state: "forced_replan",
+          reason: `${reason} — do NOT report incomplete and do NOT repeat a variant of what failed. TRIAGE: web_search the exact error/blocker to find how it is solved, OR pivot to a fundamentally different approach you have not tried, then act on it.`,
+          requiredNextAction: "creative_pivot_or_research",
           forbiddenActionFamilies: ["brute_force"]
         });
       }
@@ -576989,8 +576998,8 @@ var init_convergence_breaker = __esm({
               tripped: true,
               totalRounds,
               family,
-              reason: `failure family "${family}" has not converged after ${totalRounds} rounds (>= ${this.abandonRound}); this trajectory is dead — stop iterating and report incomplete or regenerate from the locked contract${suffix}`,
-              recommendedAction: "report_incomplete"
+              reason: `failure family "${family}" has not converged after ${totalRounds} rounds (>= ${this.abandonRound}); this trajectory is dead — do NOT report incomplete and do NOT repeat it. TRIAGE: pivot to a fundamentally different approach, or web_search the exact failure to find another route, then act on it${suffix}`,
+              recommendedAction: "creative_pivot_or_research"
             };
           case "stalled":
             return {
@@ -577345,7 +577354,7 @@ function languageOf(p2) {
     return "typescript";
   return "unknown";
 }
-var JsonConvergenceStore, EDIT_TOOLS, LongHaulComponents, FIELD_STOPWORDS;
+var JsonConvergenceStore, EDIT_TOOLS, LOCKED_CONTRACT_FILE, LongHaulComponents, FIELD_STOPWORDS;
 var init_longhaul_integration = __esm({
   "packages/orchestrator/dist/longhaul-integration.js"() {
     "use strict";
@@ -577397,6 +577406,7 @@ var init_longhaul_integration = __esm({
       }
     };
     EDIT_TOOLS = /* @__PURE__ */ new Set(["file_edit", "file_patch", "batch_edit"]);
+    LOCKED_CONTRACT_FILE = "locked-contract.json";
     LongHaulComponents = class {
       convergenceBreaker;
       adaptiveEdit;
@@ -577411,7 +577421,10 @@ var init_longhaul_integration = __esm({
       locked = /* @__PURE__ */ new Map();
       /** WO-11: provenance — which file each locked symbol was declared in. */
       lockedSource = /* @__PURE__ */ new Map();
+      /** Persisted contract output path (relative to stateDir). */
+      lockedContractPath;
       constructor(options2) {
+        this.lockedContractPath = path7.join(options2.stateDir, LOCKED_CONTRACT_FILE);
         this.convergenceBreaker = new ConvergenceBreaker({
           ...options2.convergence,
           // Persist the cliff across sessions only when persistence is enabled;
@@ -577483,6 +577496,7 @@ var init_longhaul_integration = __esm({
               this.lockedSource.set(s2.name, input.path);
             }
           }
+          this.persistLockedContract();
           return this.locked.size;
         } catch {
           return this.locked.size;
@@ -577492,6 +577506,22 @@ var init_longhaul_integration = __esm({
       lockedContract() {
         return { symbols: [...this.locked.values()] };
       }
+      /**
+       * Persist the locked contract to `.omnius/locked-contract.json` so sub-agent
+       * fixers can read it as their canonical type reference. Fault-tolerant —
+       * never throws; on error the in-memory contract remains available for
+       * orchestrator-side gates.
+       */
+      persistLockedContract() {
+        try {
+          const contract = this.lockedContract();
+          if (contract.symbols.length === 0)
+            return;
+          fs6.mkdirSync(path7.dirname(this.lockedContractPath), { recursive: true });
+          fs6.writeFileSync(this.lockedContractPath, JSON.stringify(contract, null, 2));
+        } catch {
+        }
+      }
       /** WO-11: map of locked symbol name → declaring file (for per-symbol units). */
       symbolSources() {
         return new Map(this.lockedSource);
@@ -577576,17 +577606,53 @@ var init_longhaul_integration = __esm({
           const symbol3 = top.symbol ? ` symbol \`${top.symbol}\`` : "";
           const kind = top.kind.replace(/_/g, " ");
           const contractHint = top.symbol && this.lockedSource.has(top.symbol) ? ` The locked contract for \`${top.symbol}\` lives in ${this.lockedSource.get(top.symbol)} — match it exactly.` : "";
+          const persistHint = this.locked.size > 0 ? ` The canonical locked contract is at .omnius/${LOCKED_CONTRACT_FILE} — read it before editing and match its type names exactly.` : "";
           return `[DELEGATE — build is feedback, not the task] The build reported a stable diagnostic set. Do NOT re-run the build and do NOT keep editing in this context. Delegate ONE isolated fix to a seeded sub-agent, then re-run the build to test:
   sub_agent({
     subagent_type: "fixer",
     description: "fix ${top.symbol ?? file}",
-    prompt: "In ${file}, resolve the ${kind}${symbol3}. Read ONLY ${file} (and the file that declares${symbol3 || " the offending symbol"}). Make the minimal edit to satisfy the contract. Do not touch unrelated files. Report a one-line outcome.${contractHint}"
+    prompt: "In ${file}, resolve the ${kind}${symbol3}. Read ONLY ${file} (and the file that declares${symbol3 || " the offending symbol"}). Make the minimal edit to satisfy the contract. Do not touch unrelated files. Report a one-line outcome.${contractHint}${persistHint}"
   })
 The sub-agent works in its own small context; when it folds back, run the build once to verify the diagnostic count dropped, then delegate the next one. This is fan-out/converge — keep THIS context on trajectory, not on the raw fix.`;
         } catch {
           return null;
         }
       }
+      /**
+       * B/auto-delegation: the STRUCTURED form of buildDelegationDirective. Returns
+       * the exact args for a `sub_agent(fixer)` call scoped to the top diagnostic, so
+       * the orchestrator can dispatch the delegation ITSELF when the model refuses to
+       * (measured: 0 sub_agent calls across 89 frames of a live run despite the
+       * directive firing). Returns null when the output names no concrete unit.
+       */
+      buildDelegationCall(output) {
+        try {
+          const diags = parseCompilerDiagnostics(String(output || ""));
+          const structural = diags.filter((d2) => d2.kind === "signature_mismatch" || d2.kind === "duplicate_definition" || d2.kind === "unknown_member" || d2.kind === "unknown_symbol" || d2.kind === "type_error");
+          const top = structural.find((d2) => d2.file && d2.symbol) ?? structural.find((d2) => d2.file) ?? diags.find((d2) => d2.file) ?? structural[0] ?? diags[0];
+          if (!top || !top.file)
+            return null;
+          const file = top.file;
+          const symbol3 = top.symbol;
+          const kind = top.kind.replace(/_/g, " ");
+          const declSrc = symbol3 ? this.lockedSource.get(symbol3) : void 0;
+          const focusFiles = [
+            file,
+            ...declSrc && declSrc !== file ? [declSrc] : []
+          ];
+          const lockedRef = this.locked.size > 0 ? ` Also read .omnius/${LOCKED_CONTRACT_FILE} for the canonical type contract and match it exactly.` : "";
+          const prompt = `In ${file}, resolve the ${kind}${symbol3 ? ` for \`${symbol3}\`` : ""}. Read ONLY ${focusFiles.join(" and ")}. Make the minimal edit to satisfy the contract. Build once to verify the error is gone. Report a one-line outcome.` + (declSrc ? ` The contract for \`${symbol3}\` lives in ${declSrc} — match it exactly.` : "") + lockedRef;
+          return {
+            description: `fix ${symbol3 ?? file}`,
+            prompt,
+            focusFiles,
+            exitCriterion: `${file} compiles${symbol3 ? ` and \`${symbol3}\` matches the contract` : ""}.`,
+            symbol: symbol3
+          };
+        } catch {
+          return null;
+        }
+      }
       diagnosticGuidance(output) {
         try {
           const diags = parseCompilerDiagnostics(String(output || ""));
@@ -577621,7 +577687,10 @@ The sub-agent works in its own small context; when it folds back, run the build
         try {
           return decideCompaction(input);
         } catch {
-          return { compact: input.pressureRatio >= 0.85, reason: "fallback threshold" };
+          return {
+            compact: input.pressureRatio >= 0.85,
+            reason: "fallback threshold"
+          };
         }
       }
       /** WO-5: validate a compaction preserved pinned invariants (Slipstream). */
@@ -579682,7 +579751,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 
 // packages/orchestrator/dist/agenticRunner.js
 import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, appendFileSync as _fsAppendFileSync, unlinkSync as _fsUnlinkSync, mkdirSync as _fsMkdirSync, statSync as _fsStatSync, readdirSync as _fsReaddirSync } from "node:fs";
-import { execFile as _execFile, spawn as _spawn } from "node:child_process";
+import { execFile as _execFile, execSync as _execSync, spawn as _spawn } from "node:child_process";
 import { createHash as _createHash } from "node:crypto";
 import { join as _pathJoin, relative as _pathRelative, resolve as _pathResolve } from "node:path";
 import { tmpdir as _osTmpdir } from "node:os";
@@ -580535,9 +580604,7 @@ var init_agenticRunner = __esm({
       "web_fetch",
       "tool_search"
     ]);
-    STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS = /* @__PURE__ */ new Set([
-      "todo_write"
-    ]);
+    STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS = /* @__PURE__ */ new Set(["todo_write"]);
     TOOL_ACTION_REASON_SCHEMA = {
       type: "object",
       description: "Compact public action contract for this exact tool call. Do not include hidden chain-of-thought; use concise task-state facts.",
@@ -580564,13 +580631,7 @@ var init_agenticRunner = __esm({
           description: "Classify the action scope. Use targeted_patch for constrained edits; full_file_rewrite only for deliberate whole-file replacement."
         }
       },
-      required: [
-        "task_anchor",
-        "intent",
-        "evidence",
-        "expected_result",
-        "scope"
-      ]
+      required: ["task_anchor", "intent", "evidence", "expected_result", "scope"]
     };
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
     SYSTEM_PROMPT_MEDIUM = loadPrompt("agentic/system-medium.md");
@@ -581074,6 +581135,14 @@ var init_agenticRunner = __esm({
       _longHaul = null;
       /** WO-11: decomposition modules (files) stashed for contract-enriched todo trees. */
       _decompModules = [];
+      /** Auto-delegation: last failing build/verify output, for parsing the top unit. */
+      _lastBuildOutput = null;
+      /** Convergence gate: pre-fold error count for verifying fixer progress. */
+      _preFoldErrorCount = null;
+      /** Convergence gate: the fixer description being gated (for status messages). */
+      _preFoldFixerDescription = null;
+      /** Auto-delegation: directive ids we've already auto-delegated for (once each). */
+      _autoDelegatedDirectiveIds = /* @__PURE__ */ new Set();
       _focusTerminalLedgerRecorded = false;
       // Generic, cross-session failure→resolution learning: learns the token-level
       // change that turned a failed command into a working one (e.g. python→python3)
@@ -581457,9 +581526,13 @@ ${parts.join("\n")}
             return "file_patch, batch_edit, file_edit, or hash-guarded file_write on a different supported target";
           case "run_verification":
             return "shell running the verification/runtime command";
+          case "delegate_isolated_fix":
+            return "sub_agent(subagent_type='fixer', ...) delegating the top diagnostic to an isolated worker";
+          case "creative_pivot_or_research":
+            return "a FUNDAMENTALLY different approach: web_search the exact error/blocker to find how it is solved, or pivot to a method you have NOT tried — not a variant of what failed, and NOT task_complete";
           case "report_blocked":
           case "report_incomplete":
-            return "task_complete with the concrete blocker/incomplete evidence";
+            return "a fundamentally different approach or web_search the blocker — do not report incomplete";
           default:
             return "choose the narrowest tool that advances the current card";
         }
@@ -588573,41 +588646,27 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               "Evidence:",
               evidenceFeedback
             ].join("\n");
-            this._completionIncompleteVerification = {
-              reason,
-              summary: incompleteSummary
-            };
+            void incompleteSummary;
             this._focusSupervisor?.markTerminalIncomplete(reason, turn);
-            const terminalDirective = this._focusSupervisor?.snapshot().directive;
-            if (terminalDirective) {
+            const triageDirective = this._focusSupervisor?.snapshot().directive;
+            if (triageDirective) {
               this._emitFocusSupervisorEvent({
-                decision: "terminal_incomplete",
-                state: terminalDirective.state,
-                directiveId: terminalDirective.id,
-                reason: terminalDirective.reason,
-                requiredNextAction: terminalDirective.requiredNextAction,
+                decision: triageDirective.state,
+                state: triageDirective.state,
+                directiveId: triageDirective.id,
+                reason: triageDirective.reason,
+                requiredNextAction: triageDirective.requiredNextAction,
                 blockedTool: "task_complete",
                 turn
               });
             }
             messages2.push({
               role: "system",
-              content: `[INCOMPLETE VERIFICATION TERMINAL STATE] task_complete was held ${this._completionHoldState.count} times by the same completion gate without new evidence. The run is ending as incomplete_verification, not completed. Report the missing evidence plainly.`
+              content: `[TRIAGE] task_complete was held ${this._completionHoldState.count} times without new evidence — you keep claiming done but cannot prove it. Do NOT report incomplete. The task is not over: get the missing evidence a DIFFERENT way — web_search the exact blocker (${reason.slice(0, 160)}), or pivot to an approach you have not tried, then produce the concrete proof and only THEN call task_complete.`
             });
             this.emit({
               type: "status",
-              content: `completion gates ended run as incomplete_verification after ${this._completionHoldState.count} repeated holds: ${reason}`,
-              turn,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            this.emit({
-              type: "adversary_reaction",
-              adversary: {
-                class: "guidance",
-                shortText: "Completion gate terminal incomplete",
-                confidence: 0.9,
-                details: `Same completion gate held task_complete ${this._completionHoldState.count}x; ending incomplete_verification instead of completing.`
-              },
+              content: `[TRIAGE] completion gate held task_complete ${this._completionHoldState.count}x without evidence — steering to pivot/research instead of ending incomplete: ${reason.slice(0, 120)}`,
               turn,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
@@ -591488,7 +591547,8 @@ ${cachedResult}`,
                   blockedTool: focusDecision.kind === "block_tool_call" ? tc.name : void 0,
                   turn
                 });
-                if (focusDecision.kind === "inject_guidance") {
+                if (focusDecision.kind === "block_tool_call" && this._maybeAutoDelegate(tc, focusDecision.directive, messages2, turn)) {
+                } else if (focusDecision.kind === "inject_guidance") {
                   pushSoftInjection("system", focusDecision.message);
                 } else if (!repeatShortCircuit) {
                   repeatShortCircuit = {
@@ -593041,6 +593101,74 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   });
                 }
               }
+              if ((tc.name === "sub_agent" || tc.name === "agent") && result.success) {
+                const foldRaw = String(result.output ?? "").replace(/\s+/g, " ").trim();
+                this.emit({
+                  type: "status",
+                  content: `[CONVERGE] isolated worker folded back${foldRaw ? `: ${foldRaw.slice(0, 200)}` : ""} — orchestrator resumes trajectory (verify with a build).`,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+              if ((tc.name === "sub_agent" || tc.name === "agent") && result.success && this._preFoldErrorCount != null && this._preFoldFixerDescription) {
+                const desc = this._preFoldFixerDescription;
+                const preCount = this._preFoldErrorCount;
+                const foldOutput = String(result.output ?? result.error ?? "");
+                const postSignal = failureProgressSignal(foldOutput);
+                const cwd4 = this.authoritativeWorkingDirectory();
+                let accepted = false;
+                if (postSignal == null) {
+                  accepted = /\b(?:verified|clean|passed|succeeded|0\s*error)\b/i.test(foldOutput);
+                } else {
+                  accepted = postSignal < preCount;
+                }
+                if (accepted) {
+                  try {
+                    _execSync("git stash drop", {
+                      cwd: cwd4,
+                      stdio: "pipe",
+                      timeout: 5e3
+                    });
+                  } catch {
+                  }
+                  this.emit({
+                    type: "status",
+                    content: `[CONVERGE-ACCEPT] fixer for "${desc}" — errors ${preCount}→${postSignal != null ? postSignal : "0"}, changes kept`,
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                } else {
+                  try {
+                    _execSync("git checkout -- .", {
+                      cwd: cwd4,
+                      stdio: "pipe",
+                      timeout: 1e4
+                    });
+                    _execSync("git clean -fd", {
+                      cwd: cwd4,
+                      stdio: "pipe",
+                      timeout: 1e4
+                    });
+                  } catch {
+                  }
+                  try {
+                    _execSync("git stash pop", {
+                      cwd: cwd4,
+                      stdio: "pipe",
+                      timeout: 1e4
+                    });
+                  } catch {
+                  }
+                  this.emit({
+                    type: "status",
+                    content: `[CONVERGE-REJECT] fixer for "${desc}" — errors ${preCount}→${postSignal != null ? postSignal : "?"}, rolled back`,
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                }
+                this._preFoldErrorCount = null;
+                this._preFoldFixerDescription = null;
+              }
               try {
                 const lh = this._longHaul;
                 if (lh) {
@@ -593068,7 +593196,10 @@ ${rec.guidance}` : rec.guidance;
 
 ${dir}` : dir;
                     }
-                    lh.maybeLockContract({ path: editPath, content: writtenContent });
+                    lh.maybeLockContract({
+                      path: editPath,
+                      content: writtenContent
+                    });
                     const specDir = lh.specGateGuidance({
                       path: editPath,
                       content: writtenContent
@@ -593080,6 +593211,9 @@ ${specDir}` : specDir;
                     }
                   }
                   if (!result.success) {
+                    if (isVerificationCommand(tc.name, result.output ?? result.error ?? "")) {
+                      this._lastBuildOutput = result.output ?? result.error ?? "";
+                    }
                     const diag = lh.diagnosticGuidance(result.output ?? result.error ?? "");
                     if (diag) {
                       runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
@@ -596838,6 +596972,67 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
        * Replaces both assistant messages AND their associated tool-result
        * messages in the turn range [startTurn, currentTurn].
        */
+      /**
+       * AUTO-DELEGATION — make the fan-out actually happen.
+       *
+       * The model will not emit `sub_agent` on its own even when the focus supervisor
+       * requires delegation: on a live run we measured 0 sub_agent calls across 89
+       * frames while the `delegate_isolated_fix` directive was firing every stuck
+       * build. A directive TELLS; it does not DO. So when a delegate directive blocks
+       * the model's call, the ORCHESTRATOR dispatches the fixer itself: it rewrites
+       * the blocked call into the synthesized `sub_agent(fixer)` for the top
+       * diagnostic, which then executes through the normal path — the isolated child
+       * runs in its own small curated frame and folds a one-line result back. Guarded
+       * to once per directive id, so one stuck build produces exactly one delegation,
+       * never a spawn storm.
+       *
+       * Emits a [FAN-OUT] status marking the context switch (main frame size -> the
+       * curated worker frame) so the operator can observe the isolation boundary.
+       *
+       * Returns true if it rewrote `tc` (the caller must let it EXECUTE, not noop it).
+       */
+      _maybeAutoDelegate(tc, directive, messages2, turn) {
+        if (directive.requiredNextAction !== "delegate_isolated_fix")
+          return false;
+        if (tc.name === "sub_agent" || tc.name === "agent")
+          return false;
+        if (!this._longHaul || !this._lastBuildOutput)
+          return false;
+        if (this._autoDelegatedDirectiveIds.has(directive.id))
+          return false;
+        if (!this.tools.has("sub_agent"))
+          return false;
+        const call = this._longHaul.buildDelegationCall(this._lastBuildOutput);
+        if (!call)
+          return false;
+        this._preFoldErrorCount = failureProgressSignal(this._lastBuildOutput) ?? null;
+        this._preFoldFixerDescription = call.description;
+        try {
+          _execSync('git stash push -m "pre-fixer" --include-untracked', {
+            cwd: this.authoritativeWorkingDirectory(),
+            stdio: "pipe",
+            timeout: 1e4
+          });
+        } catch {
+        }
+        this._autoDelegatedDirectiveIds.add(directive.id);
+        const parentTok = estimateMessagesTokens2(messages2);
+        this.emit({
+          type: "status",
+          content: `[FAN-OUT] model did not delegate — orchestrator auto-dispatching an isolated fixer for "${call.description}". Main context ~${parentTok.toLocaleString()} tok -> curated worker frame (${call.focusFiles.length} focus file(s): ${call.focusFiles.join(", ")}).`,
+          turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        tc.name = "sub_agent";
+        tc.arguments = {
+          subagent_type: "fixer",
+          description: call.description,
+          prompt: call.prompt,
+          relevant_files: call.focusFiles,
+          exit_criterion: call.exitCriterion
+        };
+        return true;
+      }
       /**
        * Staleness-based evidence retirement (WO-4 realized; operator's microcompaction
        * goal). The sibling `_evictCompletedTodoMessages` only fires when a todo
@@ -596864,7 +597059,7 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
        * evidence remains on disk (`.omnius/tool-results/`) and re-materialisable.
        */
       _retireStaleEvidenceInPlace(messages2, currentTurn) {
-        if (process.env["OMNIUS_EVIDENCE_RETIREMENT"] !== "1")
+        if (process.env["OMNIUS_DISABLE_EVIDENCE_RETIREMENT"] === "1")
           return;
         const keepRecent = Math.max(0, Number(process.env["OMNIUS_EVIDENCE_KEEP_TURNS"] ?? 2));
         const minChars = Math.max(512, Number(process.env["OMNIUS_EVIDENCE_MIN_CHARS"] ?? 2e3));
@@ -607577,7 +607772,7 @@ var init_subagent_prompt = __esm({
           "If the fix requires touching more than 2 files, STOP and report that the",
           "unit is larger than one fixer — the orchestrator will re-decompose it."
         ],
-        foldFormat: 'task_complete(summary="<file>: <what you changed> — build <verified|still failing on: X>")',
+        foldFormat: 'task_complete(summary="<file>: <what you changed> — build <verified|still failing on: X> — contract <matched|diverged on: Y>")',
         mutates: true
       },
       explore: {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.480",
+  "version": "1.0.482",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.480",
+      "version": "1.0.482",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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