omnius 1.0.497 → 1.0.499

package/dist/index.js

@@ -576445,6 +576445,13 @@ var init_debugArtifactLibrary = __esm({
 });
 
 // packages/orchestrator/dist/focusSupervisor.js
+function resolveFocusSupervisorSilent(envValue = process.env["OMNIUS_FOCUS_SUPERVISOR_SILENT"]) {
+  const normalized = String(envValue ?? "").trim().toLowerCase();
+  if (normalized === "0" || normalized === "false" || normalized === "off") {
+    return false;
+  }
+  return true;
+}
 function resolveFocusSupervisorMode(configured, envValue = process.env["OMNIUS_FOCUS_SUPERVISOR"]) {
   if (configured)
     return configured;
@@ -576813,9 +576820,12 @@ var init_focusSupervisor = __esm({
       lastIgnoredDirectiveTurn = null;
       repeatedViolationCounts = /* @__PURE__ */ new Map();
       availableTools = null;
+      /** SILENCE: when true, block() downgrades to pass() (never stops a call). */
+      silent;
       constructor(options2 = {}) {
         this.mode = options2.mode ?? "auto";
         this.modelTier = options2.modelTier ?? "large";
+        this.silent = options2.silent ?? false;
         this.repeatGateMax = Math.max(0, Math.floor(options2.repeatGateMax ?? 3));
         this.availableTools = options2.availableTools ? new Set(Array.from(options2.availableTools)) : null;
         this.convergenceBreaker = options2.convergenceBreaker ?? null;
@@ -577291,6 +577301,11 @@ var init_focusSupervisor = __esm({
         };
       }
       block(directive, message2, success) {
+        if (this.silent) {
+          this.lastDecision = "block_silenced_pass";
+          this.lastReason = directive.reason;
+          return this.pass();
+        }
         this.lastDecision = "block_tool_call";
         this.lastReason = directive.reason;
         return {
@@ -582162,6 +582177,16 @@ var init_agenticRunner = __esm({
       _todoInProgressTurn = /* @__PURE__ */ new Map();
       /** Set of todo IDs that have already been chunked */
       _todoChunked = /* @__PURE__ */ new Set();
+      /**
+       * Explicit tool-output → todo binding. As each FULL tool output is
+       * externalized to .omnius/tool-results/ (the point where it would otherwise
+       * bloat the context chain), we bind it to the todo that was in_progress at
+       * that moment. On completion, that todo's ledger of full outputs is written
+       * to disk (.omnius/todo-chunks/{id}.ledger.json) alongside the summary stub,
+       * so the bulk stays retrievable but out of the live window. Keyed by todo id;
+       * "_unassigned" holds outputs produced while no leaf was in_progress.
+       */
+      _todoOutputLedger = /* @__PURE__ */ new Map();
       // -- ENOENT tracker (prevents path-guessing spirals) --
       // Tracks both consecutive AND sliding-window ENOENT counts. The sliding
       // window catches oscillation patterns (success → ENOENT → success → ENOENT)
@@ -586258,8 +586283,7 @@ ${body}`;
        * summarization, RECOMP (ICLR 2024) observation masking.
        */
       proactivePrune(messages2, currentTurn) {
-        if (process.env["OMNIUS_DISABLE_PROACTIVE_PRUNE"] === "1")
-          return;
+        return;
         const AGED_FILE_READ_TURNS = 20;
         const AGED_SHELL_TURNS = 12;
         const ERROR_MARKERS = /(?:error|fail|exception|traceback|enoent|enotfound|exit code [^0]|status[: ]+1\d?\d?)/i;
@@ -586273,125 +586297,148 @@ ${body}`;
         let scanTurn = 0;
         for (let i2 = 0; i2 < messages2.length; i2++) {
           const msg = messages2[i2];
-          if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
-            scanTurn++;
-            for (const tc of msg.tool_calls) {
-              const name10 = tc.function.name;
-              let parsedArgs;
-              try {
-                parsedArgs = JSON.parse(tc.function.arguments || "{}");
-              } catch {
-                parsedArgs = void 0;
-              }
-              const fp = parsedArgs ? this._buildToolFingerprint(name10, parsedArgs) : `${name10}:raw#sha256:${_createHash("sha256").update(tc.function.arguments ?? "").digest("hex").slice(0, 20)}`;
-              let resultIdx = -1;
-              for (let j = i2 + 1; j < Math.min(messages2.length, i2 + 8); j++) {
-                const r2 = messages2[j];
-                if (r2.role === "tool" && r2.tool_call_id === tc.id) {
-                  resultIdx = j;
-                  break;
-                }
-              }
-              if (resultIdx === -1)
-                continue;
-              const resultMsg = messages2[resultIdx];
-              const content = typeof resultMsg.content === "string" ? resultMsg.content : "";
-              if (content.startsWith(PRUNE_PREFIX) || content.startsWith(DEDUPE_PREFIX) || content.startsWith(FILE_AGED_PREFIX) || content.startsWith(SHELL_AGED_PREFIX)) {
-                if (!seen.has(fp))
-                  seen.set(fp, { turn: scanTurn, idx: resultIdx });
-                continue;
+          if (msg.role !== "assistant") {
+            continue;
+          }
+          const toolCalls = msg.tool_calls ?? [];
+          if (toolCalls.length === 0) {
+            continue;
+          }
+          scanTurn++;
+          for (const tc of toolCalls) {
+            const name10 = tc.function.name;
+            let parsedArgs;
+            try {
+              parsedArgs = JSON.parse(tc.function.arguments || "{}");
+            } catch {
+              parsedArgs = void 0;
+            }
+            const fp = parsedArgs ? this._buildToolFingerprint(name10, parsedArgs) : `${name10}:raw#sha256:${_createHash("sha256").update(tc.function.arguments ?? "").digest("hex").slice(0, 20)}`;
+            let resultIdx = -1;
+            for (let j = i2 + 1; j < Math.min(messages2.length, i2 + 8); j++) {
+              const r2 = messages2[j];
+              if (r2.role === "tool" && r2.tool_call_id === tc.id) {
+                resultIdx = j;
+                break;
               }
-              const prior = seen.get(fp);
-              if (prior) {
-                const priorContent = typeof messages2[prior.idx]?.content === "string" ? messages2[prior.idx].content : "";
+            }
+            if (resultIdx === -1)
+              continue;
+            const resultMsg = messages2[resultIdx];
+            const contentText = textFromMessageContent(resultMsg.content);
+            if (contentText.startsWith(PRUNE_PREFIX) || contentText.startsWith(DEDUPE_PREFIX) || contentText.startsWith(FILE_AGED_PREFIX) || contentText.startsWith(SHELL_AGED_PREFIX)) {
+              if (!seen.has(fp))
+                seen.set(fp, { turn: scanTurn, idx: resultIdx });
+              continue;
+            }
+            const priorIdx = seen.get(fp)?.idx;
+            if (priorIdx === void 0) {
+              seen.set(fp, { turn: scanTurn, idx: resultIdx });
+            } else {
+              const priorIdxSafe = priorIdx;
+              const priorMessage = messages2[priorIdxSafe];
+              if (priorMessage) {
+                const priorContent = textFromMessageContent(priorMessage.content);
                 const priorFailed = ERROR_MARKERS.test(priorContent);
                 pending2.push({
-                  idx: prior.idx,
+                  idx: priorIdxSafe,
                   reason: "dedupe",
                   replacement: priorFailed ? `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call; the earlier call FAILED (same error as the retained copy below). Do not retry identically.]` : `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call]`
                 });
-                seen.set(fp, { turn: scanTurn, idx: resultIdx });
-                continue;
               }
-              seen.set(fp, { turn: scanTurn, idx: resultIdx });
-              const rkey = this._buildResourceKey(name10, parsedArgs);
-              if (rkey) {
-                const priorResource = seenResource.get(rkey);
-                if (priorResource && priorResource.idx !== resultIdx) {
-                  const priorContent = typeof messages2[priorResource.idx]?.content === "string" ? messages2[priorResource.idx].content : "";
+              continue;
+            }
+            const rkey = this._buildResourceKey(name10, parsedArgs);
+            if (rkey) {
+              const priorResourceIdx = seenResource.get(rkey)?.idx;
+              if (priorResourceIdx === void 0) {
+                seenResource.set(rkey, { turn: scanTurn, idx: resultIdx });
+              } else if (priorResourceIdx !== resultIdx) {
+                const priorResourceIdxSafe = priorResourceIdx;
+                const priorResourceMessage = messages2[priorResourceIdxSafe];
+                if (priorResourceMessage) {
+                  const priorContent = textFromMessageContent(priorResourceMessage.content);
                   if (!priorContent.startsWith(PRUNE_PREFIX) && !priorContent.startsWith(DEDUPE_PREFIX) && !priorContent.startsWith(FILE_AGED_PREFIX)) {
                     const priorResFailed = ERROR_MARKERS.test(priorContent);
                     pending2.push({
-                      idx: priorResource.idx,
+                      idx: priorResourceIdxSafe,
                       reason: "dedupe",
                       replacement: priorResFailed ? `${DEDUPE_PREFIX} ${scanTurn} — semantic duplicate ${name10}() (same resource: ${rkey}); the earlier call FAILED. Do not retry identically.]` : `${DEDUPE_PREFIX} ${scanTurn} — semantic duplicate ${name10}() (same resource: ${rkey})]`
                     });
                   }
                 }
                 seenResource.set(rkey, { turn: scanTurn, idx: resultIdx });
+              } else {
+                seenResource.set(rkey, {
+                  turn: scanTurn,
+                  idx: priorResourceIdx
+                });
               }
-              const ageTurns = currentTurn - scanTurn;
-              const wasRecentlyWritten = (() => {
-                try {
-                  const o2 = JSON.parse(tc.function.arguments || "{}");
-                  const p2 = String(o2.path ?? o2.file ?? "");
-                  for (let k = Math.max(0, i2 - 20); k < i2; k++) {
-                    const m2 = messages2[k];
-                    if (m2.role === "assistant" && m2.tool_calls) {
-                      for (const tc2 of m2.tool_calls) {
-                        if ((tc2.function.name === "file_edit" || tc2.function.name === "file_write" || tc2.function.name === "file_patch") && tc2.function.arguments?.includes(p2)) {
-                          return true;
-                        }
+            }
+            const ageTurns = currentTurn - scanTurn;
+            const wasRecentlyWritten = (() => {
+              try {
+                const o2 = JSON.parse(tc.function.arguments || "{}");
+                const p2 = String(o2.path ?? o2.file ?? "");
+                for (let k = Math.max(0, i2 - 20); k < i2; k++) {
+                  const m2 = messages2[k];
+                  const priorTurnToolCalls = m2.tool_calls ?? [];
+                  if (m2.role === "assistant") {
+                    for (const tc2 of priorTurnToolCalls) {
+                      if ((tc2.function.name === "file_edit" || tc2.function.name === "file_write" || tc2.function.name === "file_patch") && tc2.function.arguments?.includes(p2)) {
+                        return true;
                       }
                     }
                   }
-                  return false;
+                }
+                return false;
+              } catch {
+                return false;
+              }
+            })();
+            if (name10 === "file_read" && ageTurns > AGED_FILE_READ_TURNS && contentText.length > 200 && !wasRecentlyWritten) {
+              const pathArg = (() => {
+                try {
+                  const o2 = JSON.parse(tc.function.arguments || "{}");
+                  return String(o2.path ?? o2.file ?? "?");
                 } catch {
-                  return false;
+                  return "?";
                 }
               })();
-              if (name10 === "file_read" && ageTurns > AGED_FILE_READ_TURNS && content.length > 200 && !wasRecentlyWritten) {
-                const pathArg = (() => {
-                  try {
-                    const o2 = JSON.parse(tc.function.arguments || "{}");
-                    return String(o2.path ?? o2.file ?? "?");
-                  } catch {
-                    return "?";
-                  }
-                })();
-                const lines = content.split("\n");
-                const lineCount = lines.length;
-                const contentPreview = content.slice(0, 500);
-                pending2.push({
-                  idx: resultIdx,
-                  reason: "aged_file",
-                  replacement: `${FILE_AGED_PREFIX} path=${pathArg}, ${lineCount} lines, ${content.length} chars]
+              const lines = contentText.split("\n");
+              const lineCount = lines.length;
+              const contentPreview = contentText.slice(0, 500);
+              pending2.push({
+                idx: resultIdx,
+                reason: "aged_file",
+                replacement: `${FILE_AGED_PREFIX} path=${pathArg}, ${lineCount} lines, ${contentText.length} chars]
 ${contentPreview}
 [End of aged file_read preview — do NOT re-read this file, use the content above]`
-                });
-                continue;
-              }
-              if ((name10 === "shell" || name10 === "shell_async" || name10 === "run_tests") && ageTurns > AGED_SHELL_TURNS && content.length > 200 && !ERROR_MARKERS.test(content)) {
-                const cmdArg = (() => {
-                  try {
-                    const o2 = JSON.parse(tc.function.arguments || "{}");
-                    return String(o2.command ?? o2.cmd ?? "?").slice(0, 80);
-                  } catch {
-                    return "?";
-                  }
-                })();
-                pending2.push({
-                  idx: resultIdx,
-                  reason: "aged_shell",
-                  replacement: `${SHELL_AGED_PREFIX} command="${cmdArg}", output ${content.length} chars, no error markers detected]`
-                });
-              }
+              });
+              continue;
+            }
+            if ((name10 === "shell" || name10 === "shell_async" || name10 === "run_tests") && ageTurns > AGED_SHELL_TURNS && contentText.length > 200 && !ERROR_MARKERS.test(contentText)) {
+              const cmdArg = (() => {
+                try {
+                  const o2 = JSON.parse(tc.function.arguments || "{}");
+                  return String(o2.command ?? o2.cmd ?? "?").slice(0, 80);
+                } catch {
+                  return "?";
+                }
+              })();
+              pending2.push({
+                idx: resultIdx,
+                reason: "aged_shell",
+                replacement: `${SHELL_AGED_PREFIX} command="${cmdArg}", output ${contentText.length} chars, no error markers detected]`
+              });
             }
           }
         }
         if (pending2.length === 0)
           return;
-        let dedupes = 0, agedFiles = 0, agedShells = 0;
+        let dedupes = 0;
+        let agedFiles = 0;
+        let agedShells = 0;
         for (const p2 of pending2) {
           const m2 = messages2[p2.idx];
           if (!m2)
@@ -587527,7 +587574,7 @@ ${sections.join("\n")}` : sections.join("\n");
           }
         }
         const sections = [
-          "[KNOWLEDGE — cached tool results already known to the runtime. Repeating an exact read/list/search/shell call is a wasted action and will be blocked or served from cache:]"
+          "[KNOWLEDGE — recent tool results for reference. Re-reading a file after an edit is encouraged to capture the latest content; exact re-reads are NOT blocked and always return fresh, up-to-date data.]"
         ];
         if (compactedCount > 0) {
           sections.push(`Compacted cached entries still count as already-known results (${compactedCount}); an exact repeat will be served from cache or skipped, not produce new information.`);
@@ -588419,8 +588466,7 @@ ${blob}
       /** Extract (path, [start,end], whole) for a region-coalesceable read, else null. */
       _readIntervalFromArgs(name10, args) {
         const canonical = this.lookupRegisteredTool(name10)?.name ?? name10;
-        if (canonical !== "file_read")
-          return null;
+        return null;
         const a2 = args ?? {};
         const path13 = typeof a2["path"] === "string" && a2["path"] || typeof a2["file"] === "string" && a2["file"] || typeof a2["file_path"] === "string" && a2["file_path"] || "";
         if (!path13)
@@ -588428,8 +588474,12 @@ ${blob}
         const offset = typeof a2["offset"] === "number" ? a2["offset"] : void 0;
         const limit = typeof a2["limit"] === "number" ? a2["limit"] : void 0;
         const whole = offset === void 0 && limit === void 0;
+        const safeLimit = limit ?? 0;
         const start2 = Math.max(1, offset ?? 1);
-        const end = whole ? Number.POSITIVE_INFINITY : limit !== void 0 ? start2 + Math.max(0, limit) - 1 : Number.POSITIVE_INFINITY;
+        let end = Number.POSITIVE_INFINITY;
+        if (!whole) {
+          end = start2 + Math.max(0, safeLimit) - 1;
+        }
         return { key: `${canonical}|${path13}`, start: start2, end, whole };
       }
       /**
@@ -589392,6 +589442,12 @@ Respond with your assessment, then take action.`;
         this._focusSupervisor = this.options.focusSupervisor === "off" ? null : new FocusSupervisor({
           mode: this.options.focusSupervisor,
           modelTier: this.options.modelTier,
+          // SILENCE (operator directive): the supervisor must not stop agents
+          // or re-serve cached responses from earlier commands. It observes,
+          // sets directives, and advises, but every hard block downgrades to a
+          // pass so the model is free to act — including re-reading to confirm
+          // a change landed. Restore blocking with OMNIUS_FOCUS_SUPERVISOR_SILENT=0.
+          silent: resolveFocusSupervisorSilent(),
           repeatGateMax: this._resolveRepeatGateMax(),
           availableTools: this.tools.keys(),
           // WO-3: convergence circuit-breaker escalates a non-converging
@@ -589508,6 +589564,7 @@ Respond with your assessment, then take action.`;
         }
         this._fileRegistry.clear();
         this._memexArchive.clear();
+        this._todoOutputLedger.clear();
         this._sessionId = this.options.sessionId && String(this.options.sessionId) || process.env["OMNIUS_SESSION_ID"] && String(process.env["OMNIUS_SESSION_ID"]) || `session-${Date.now()}`;
         this._appState = createAppState({
           sessionId: this._sessionId,
@@ -592210,7 +592267,7 @@ ${memoryLines.join("\n")}`
           if (msg.toolCalls && msg.toolCalls.length > 0) {
             consecutiveTextOnly = 0;
             consecutiveThinkOnly = 0;
-            msg.toolCalls = this._dedupeToolCallsForResponse(msg.toolCalls, turn);
+            msg.toolCalls = msg.toolCalls;
             if (msg.toolCalls.length === 0) {
               messages2.push({
                 role: "system",
@@ -592937,7 +592994,7 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 }
                 const _repeatGateMax = this._resolveRepeatGateMax();
                 const isFailedShellRepeat = tc.name === "shell" && typeof _existingFp?.result === "string" && _existingFp.result.includes("status: failure") && !shellLikelyMutatesFilesystem;
-                const repeatGateEligible = isReadLike || tc.name === "memory_write" || isFailedShellRepeat;
+                const repeatGateEligible = tc.name === "memory_write" || isFailedShellRepeat;
                 const suppressSuccessfulShellCacheGuidance = tc.name === "shell" && !isFailedShellRepeat;
                 if (suppressSuccessfulShellCacheGuidance)
                   criticGuidance = null;
@@ -595962,7 +596019,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             if (msg.toolCalls && msg.toolCalls.length > 0) {
               consecutiveTextOnly = 0;
               consecutiveThinkOnly = 0;
-              msg.toolCalls = this._dedupeToolCallsForResponse(msg.toolCalls, turn);
+              msg.toolCalls = msg.toolCalls;
               if (msg.toolCalls.length === 0) {
                 messages2.push({
                   role: "system",
@@ -597994,6 +598051,17 @@ ${result.output}`, "utf-8");
         } catch {
         }
         const savedPath = _pathJoin(this.omniusStateDir(), "tool-results", `${handleId}.txt`);
+        this._recordTodoOutputLedgerEntry({
+          memexId: handleId,
+          toolName,
+          target: this.extractPrimaryToolPath(args) || "",
+          diskPath: savedPath,
+          chars: result.output.length,
+          lineCount,
+          turn,
+          preview: preview.slice(0, 200),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
         const folded = this.foldOutput(modelContent, maxLen);
         return this.wrapToolOutputForModel(toolName, `[Tool output truncated — ${result.output.length} chars, ${lineCount} lines]
 Full output saved to: ${savedPath}
@@ -598213,6 +598281,76 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
         return content;
       }
       // ---------------------------------------------------------------------------
+      // Part 3 — per-todo full-tool-output ledger
+      // ---------------------------------------------------------------------------
+      /**
+       * The id of the todo currently in_progress (the deepest in_progress leaf), or
+       * "_unassigned" when nothing is active. Full outputs externalized while this
+       * is active are bound to it so completion can flush a consolidated ledger.
+       */
+      _activeTodoId() {
+        try {
+          const todos = this.readSessionTodos() || [];
+          const inProgress = todos.filter((t2) => t2.status === "in_progress");
+          if (inProgress.length === 0)
+            return "_unassigned";
+          const childless = inProgress.filter((t2) => !todos.some((c9) => c9.parentId === t2.id));
+          const chosen = childless[childless.length - 1] ?? inProgress[inProgress.length - 1];
+          return chosen.id || "_unassigned";
+        } catch {
+          return "_unassigned";
+        }
+      }
+      /** Bind one externalized full output to the active todo's ledger. */
+      _recordTodoOutputLedgerEntry(entry) {
+        try {
+          const key = this._activeTodoId();
+          let bucket = this._todoOutputLedger.get(key);
+          if (!bucket) {
+            bucket = [];
+            this._todoOutputLedger.set(key, bucket);
+          }
+          bucket.push(entry);
+          const cap = 500;
+          if (bucket.length > cap)
+            bucket.splice(0, bucket.length - cap);
+        } catch {
+        }
+      }
+      /**
+       * Flush a completed todo's full-output ledger to disk as a single compressed
+       * index alongside its summary chunk, then drop it from memory. The full
+       * bodies stay in .omnius/tool-results/; this file is the high-signal,
+       * low-noise stub that lists what was produced and where to retrieve it.
+       * Returns the ledger path when written, else null.
+       */
+      _flushTodoOutputLedger(todoId, todoContent, workingDir) {
+        try {
+          const bucket = this._todoOutputLedger.get(todoId);
+          if (!bucket || bucket.length === 0)
+            return null;
+          const totalChars = bucket.reduce((n2, e2) => n2 + (e2.chars || 0), 0);
+          const dir = _pathJoin(workingDir, ".omnius", "todo-chunks");
+          _fsMkdirSync(dir, { recursive: true });
+          const safeId3 = todoId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+          const ledgerPath = _pathJoin(dir, `${safeId3}.ledger.json`);
+          _fsWriteFileSync(ledgerPath, JSON.stringify({
+            todoId,
+            todoContent: todoContent.slice(0, 300),
+            entryCount: bucket.length,
+            totalChars,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // High-signal, low-noise stubs. Each points at its full body on disk
+            // and via memex_retrieve(memexId) for on-demand re-materialisation.
+            outputs: bucket
+          }, null, 2), "utf-8");
+          this._todoOutputLedger.delete(todoId);
+          return { path: ledgerPath, entryCount: bucket.length, totalChars };
+        } catch {
+          return null;
+        }
+      }
+      // ---------------------------------------------------------------------------
       // Todo context chunker: fire-and-forget summarization of completed todo work
       // ---------------------------------------------------------------------------
       /**
@@ -598235,6 +598373,15 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
           sessionId: this._sessionId
         };
         this._evictCompletedTodoMessages(startTurn, currentTurn, todoId, todo.content, messages2);
+        const _ledger = this._flushTodoOutputLedger(todoId, todo.content, workingDir);
+        if (_ledger) {
+          this.emit({
+            type: "status",
+            content: `[todo-ledger] "${todo.content.slice(0, 60)}": ${_ledger.entryCount} full output(s) (~${Math.round(_ledger.totalChars / 4)} tok) consolidated to ${_ledger.path} — retrievable via memex_retrieve or the tool-results files`,
+            turn: currentTurn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         runTodoChunker({
           inputs,
           callable: async (prompt) => {
@@ -608924,7 +609071,7 @@ function canonicalize(value2) {
   return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(obj[k])}`).join(",")}}`;
 }
 function shouldBlockCall(fingerprint, history, opts = {}) {
-  const blockOnPriorSuccess = opts.blockOnPriorSuccess ?? true;
+  const blockOnPriorSuccess = opts.blockOnPriorSuccess ?? false;
   const maxIdenticalErrors = opts.maxIdenticalErrors ?? 2;
   const same = history.filter((h) => h.fingerprint === fingerprint);
   if (same.length === 0)
@@ -745514,30 +745661,9 @@ function extractEnhancedPrompt(raw) {
   if (!text2.startsWith("{") && !text2.startsWith("[")) return text2;
   return null;
 }
-async function enhancePromptViaInference(seed, ctx3) {
+async function enhancePromptViaInference(seed, backend, ctx3) {
   const seedText = seed.trim();
   if (!seedText) return null;
-  let backend;
-  try {
-    if (ctx3.config.backendType === "nexus") {
-      const nexusTool = new NexusTool(ctx3.repoRoot);
-      const peer = ctx3.config.backendUrl.startsWith("peer://") ? ctx3.config.backendUrl.slice(7) : void 0;
-      backend = new NexusAgenticBackend(
-        nexusTool.sendCommand.bind(nexusTool),
-        ctx3.config.model,
-        peer,
-        ctx3.config.apiKey
-      );
-    } else {
-      backend = new OllamaAgenticBackend(
-        ctx3.config.backendUrl,
-        ctx3.config.model,
-        ctx3.config.apiKey
-      );
-    }
-  } catch {
-    return null;
-  }
   const recent = ctx3.recentHistory.filter((h) => h && h.trim()).slice(0, 5).map((h, i2) => `  ${i2 + 1}. ${h.trim().slice(0, 240)}`).join("\n");
   let runtimeCtx = "";
   try {
@@ -747180,8 +747306,13 @@ This is an independent background session started from /background.`
     }
   });
   statusBar.setEnhanceHandler(async (seedPrompt) => {
-    return enhancePromptViaInference(seedPrompt, {
-      config: currentConfig,
+    let enhanceBackend;
+    try {
+      enhanceBackend = activeTask ? activeTask.runner.getBackend() : await createSteeringIntakeBackend(currentConfig, repoRoot);
+    } catch {
+      return null;
+    }
+    return enhancePromptViaInference(seedPrompt, enhanceBackend, {
       repoRoot,
       recentHistory: savedHistory,
       activeGoal: activeTask ? lastSubmittedPrompt : void 0

package/npm-shrinkwrap.json

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

package/package.json

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