omnius 1.0.480 → 1.0.481

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 {
@@ -577587,6 +577596,37 @@ The sub-agent works in its own small context; when it folds back, run the build
           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 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.` : "");
+          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 || ""));
@@ -581074,6 +581114,10 @@ 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;
+      /** 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 +581501,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 +588621,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 +591522,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 +593076,15 @@ 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()
+                });
+              }
               try {
                 const lh = this._longHaul;
                 if (lh) {
@@ -593080,6 +593124,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 +596885,57 @@ 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._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 +596962,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));

package/npm-shrinkwrap.json

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

package/package.json

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