omnius 1.0.269 → 1.0.271

package/dist/index.js

@@ -546546,7 +546546,10 @@ var init_agent_tool = __esm({
           lines.push(prompt);
           return lines.join("\n");
         })();
-        if (isolation === "worktree") {
+        const fullDefault = process.env["OMNIUS_FULL_SUBAGENT_DEFAULT"] !== "0";
+        const workCapableType = subagentType === "general" || subagentType === "coordinator";
+        const routeToSubprocess = isolation === "worktree" || fullDefault && runInBackground && workCapableType;
+        if (routeToSubprocess) {
           this.callbacks.onViewRegister?.(agentId, label);
           const spawn35 = this.callbacks.spawnSubprocess({
             id: agentId,
@@ -555351,6 +555354,31 @@ var init_textSanitize = __esm({
   }
 });
 
+// packages/orchestrator/dist/permissionRuleset.js
+function checkDoomLoop(context2) {
+  const history = context2.toolCallHistory;
+  if (!history || history.length < 3)
+    return null;
+  const lastCall = history[history.length - 1];
+  const recent = history.slice(-4);
+  let identicalCount = 1;
+  for (let i2 = history.length - 2; i2 >= Math.max(0, history.length - 4); i2--) {
+    const prev = history[i2];
+    if (prev.tool === lastCall.tool && JSON.stringify(prev.args) === JSON.stringify(lastCall.args)) {
+      identicalCount++;
+    }
+  }
+  if (identicalCount >= 3) {
+    return "ask";
+  }
+  return null;
+}
+var init_permissionRuleset = __esm({
+  "packages/orchestrator/dist/permissionRuleset.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/completionContract.js
 function normalizeText(value2, max = 500) {
   const text2 = String(value2 ?? "").trim().replace(/\s+/g, " ");
@@ -565337,6 +565365,7 @@ var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
     init_textSanitize();
+    init_permissionRuleset();
     init_completionLedger();
     init_dist6();
     init_ollama_pool();
@@ -565449,7 +565478,7 @@ var init_agenticRunner = __esm({
       "repl_exec",
       "notebook_edit"
     ]);
-    AgenticRunner = class {
+    AgenticRunner = class _AgenticRunner {
       backend;
       tools = /* @__PURE__ */ new Map();
       options;
@@ -567832,10 +567861,12 @@ ${body}`;
               }
               const prior = seen.get(fp);
               if (prior) {
+                const priorContent = typeof messages2[prior.idx]?.content === "string" ? messages2[prior.idx].content : "";
+                const priorFailed = ERROR_MARKERS.test(priorContent);
                 pending2.push({
                   idx: prior.idx,
                   reason: "dedupe",
-                  replacement: `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call]`
+                  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;
@@ -567847,10 +567878,11 @@ ${body}`;
                 if (priorResource && priorResource.idx !== resultIdx) {
                   const priorContent = typeof messages2[priorResource.idx]?.content === "string" ? messages2[priorResource.idx].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,
                       reason: "dedupe",
-                      replacement: `${DEDUPE_PREFIX} ${scanTurn} — semantic duplicate ${name10}() (same resource: ${rkey})]`
+                      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})]`
                     });
                   }
                 }
@@ -570656,6 +570688,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         this._worldFacts = { files: /* @__PURE__ */ new Map(), lastTest: {}, lastLists: /* @__PURE__ */ new Map() };
         this._argCohorts.clear();
         this._adversaryRedundantSignals.clear();
+        this._adversaryRecentFlags.clear();
         this._lastTodoWriteTurn = -1;
         this._lastTodoReminderTurn = -1;
         let pendingConstraintWarnings = [];
@@ -572789,6 +572822,44 @@ Corrective action: try a different approach first: read relevant files, adjust a
                 timestampMs: Date.now()
               });
               const _toolLogTailIdx = toolCallLog.length - 1;
+              if (tc.name !== "task_complete") {
+                const doomHistory = toolCallLog.slice(-5).map((e2) => ({ tool: e2.name, args: e2.argsKey }));
+                doomHistory.push({
+                  tool: tc.name,
+                  args: this._buildExactArgsKey(tc.arguments ?? {})
+                });
+                const doom = checkDoomLoop({
+                  permission: tc.name,
+                  target: "",
+                  toolCallHistory: doomHistory
+                });
+                if (doom === "ask" && cohort && cohort.failure >= 3 && cohort.success === 0) {
+                  const stopMsg = `[blocked: doom-loop] '${tc.name}' has been called with identical arguments 3+ times and has failed every time. This exact call was NOT executed. Stop repeating it. Choose ONE: (a) change the arguments or approach, (b) read/inspect to understand why it fails, or (c) if genuinely blocked, call task_complete and state the blocker plainly.`;
+                  this.emit({
+                    type: "tool_call",
+                    toolName: tc.name,
+                    toolArgs: tc.arguments,
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  const lastLog = toolCallLog[_toolLogTailIdx];
+                  if (lastLog) {
+                    lastLog.success = false;
+                    lastLog.mutated = false;
+                    lastLog.mutatedFiles = [];
+                    lastLog.outputPreview = stopMsg.slice(0, 100);
+                  }
+                  this.emit({
+                    type: "tool_result",
+                    toolName: tc.name,
+                    success: false,
+                    content: stopMsg.slice(0, 200),
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  return { tc, output: stopMsg, success: false };
+                }
+              }
               if (editFeedbackRequiredBeforeMoreEdits && this._isProjectEditTool(tc.name)) {
                 this.emit({
                   type: "tool_call",
@@ -573970,8 +574041,23 @@ Respond with EXACTLY this structure before your next tool call:
                 }
               }
               const isFileMutation = realFileMutation;
-              if (isFileMutation && dedupHitCount.size > 0) {
-                dedupHitCount.clear();
+              if (isFileMutation) {
+                if (realMutationPaths.length > 0) {
+                  for (const mp of realMutationPaths) {
+                    if (!mp)
+                      continue;
+                    for (const key of Array.from(dedupHitCount.keys())) {
+                      if (key.includes(mp))
+                        dedupHitCount.delete(key);
+                    }
+                    for (const key of Array.from(recentToolResults.keys())) {
+                      if (key.includes(mp))
+                        recentToolResults.delete(key);
+                    }
+                  }
+                } else if (dedupHitCount.size > 0) {
+                  dedupHitCount.clear();
+                }
               }
               if (isFileMutation && recentToolResults.size > 0) {
                 for (const key of Array.from(recentToolResults.keys())) {
@@ -574803,7 +574889,6 @@ ${sr.result.output}`;
             }
             if (completed || this._completionIncompleteVerification)
               break;
-            this.adversaryObserve(messages2, turn);
             const currentRepScore = this.detectRepetition(toolCallLog);
             if (currentRepScore > 0.4 && toolCallLog.length >= 4) {
               const { repetitionWindow } = this.contextLimits();
@@ -577896,6 +577981,13 @@ ${trimmedNew}`;
       /** WO-FIX-C: Tool fingerprints the adversary has flagged as redundant.
        *  Checked in executeSingle to attach advisory guidance before dispatch. */
       _adversaryRedundantSignals = /* @__PURE__ */ new Set();
+      /** Tracks recent adversary detection flags for deduplication and escalation.
+       *  Key: "detectionType:fingerprint"
+       *  Value: { count: number; lastTurn: number }
+       *  When count >= ESCALATE_THRESHOLD, the critique is promoted to system-role. */
+      _adversaryRecentFlags = /* @__PURE__ */ new Map();
+      static ADVERSARY_ESCALATE_THRESHOLD = 3;
+      static ADVERSARY_FLAG_TTL = 5;
       /** Reflexion pattern: task-local failure-indexed reflection buffer.
        *  Generates typed self-reflections on task failure and injects them
        *  into the next attempt's context for active learning. */
@@ -577958,6 +578050,23 @@ ${trimmedNew}`;
         }
         while (this._adversaryToolOutcomes.length > 20)
           this._adversaryToolOutcomes.shift();
+        for (const [key, val] of this._adversaryRecentFlags) {
+          if (turn - val.lastTurn > _AgenticRunner.ADVERSARY_FLAG_TTL)
+            this._adversaryRecentFlags.delete(key);
+        }
+        const adversaryFlag = (flagKey, messages3) => {
+          const existing = this._adversaryRecentFlags.get(flagKey);
+          if (existing) {
+            existing.count++;
+            existing.lastTurn = turn;
+            if (existing.count >= _AgenticRunner.ADVERSARY_ESCALATE_THRESHOLD) {
+              return "escalate";
+            }
+            return "suppress";
+          }
+          this._adversaryRecentFlags.set(flagKey, { count: 1, lastTurn: turn });
+          return "proceed";
+        };
         const emitReaction = (cls, shortText, confidence2, details2) => {
           this.emit({
             type: "adversary_reaction",
@@ -577985,9 +578094,9 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
             const successes = recentOutcomes.filter((o2) => o2.succeeded);
             if (successes.length >= 1) {
               const successList = successes.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
-              emitReaction("false_failure", `Claimed failure, but recent tools succeeded (${successes.length})`, 0.9, successList);
-              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                this.pendingUserMessages.push(buildAdversaryCritique({
+              const ffFlag = adversaryFlag("false_failure", messages2);
+              if (ffFlag !== "suppress") {
+                const critiqueText = buildAdversaryCritique({
                   evidence: `Recent tools succeeded: ${successList}.`,
                   hypothesis: "The main loop is interpreting uncertainty or partial progress as failure and may be about to discard usable evidence.",
                   correctiveAction: "Use the successful results to advance the task, then verify the next concrete step.",
@@ -577996,13 +578105,24 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
                     "Read a different targeted file if the successful result exposed a new path or symbol.",
                     "Complete only if the successful output is sufficient evidence for the user's request."
                   ]
-                }));
+                });
+                emitReaction("false_failure", `Claimed failure, but recent tools succeeded (${successes.length})`, 0.9, successList);
+                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                  if (ffFlag === "escalate") {
+                    messages2.push({
+                      role: "system",
+                      content: critiqueText + "\n[ESCALATED: This warning was previously issued without effect.]"
+                    });
+                  } else {
+                    this.pendingUserMessages.push(critiqueText);
+                  }
+                }
+                this.emit({
+                  type: "status",
+                  content: `\x1B[38;5;178m⚠ Corrected false failure claim (${successes.length} tools succeeded)\x1B[0m`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
               }
-              this.emit({
-                type: "status",
-                content: `\x1B[38;5;178m⚠ Corrected false failure claim (${successes.length} tools succeeded)\x1B[0m`,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
             }
           }
         }
@@ -578015,9 +578135,9 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
             const successes = recentOutcomes.filter((o2) => o2.succeeded);
             if (failures.length > 0 && successes.length === 0) {
               const failList = failures.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
-              emitReaction("false_success", `Claimed success, but recent tools failed (${failures.length})`, 0.9, failList);
-              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                this.pendingUserMessages.push(buildAdversaryCritique({
+              const fsFlag = adversaryFlag("false_success", messages2);
+              if (fsFlag !== "suppress") {
+                const critiqueText = buildAdversaryCritique({
                   evidence: `Recent tools show errors (${failures.length}): ${failList}.`,
                   hypothesis: "The main loop is prematurely compressing intent into success language before the verifier produced evidence.",
                   correctiveAction: "Inspect the failed output, identify the implicated path/symbol/command, and run one focused corrective step before claiming success.",
@@ -578026,7 +578146,18 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
                     "Patch the implicated code or configuration.",
                     "Run the same verifier only after a state-changing fix."
                   ]
-                }));
+                });
+                emitReaction("false_success", `Claimed success, but recent tools failed (${failures.length})`, 0.9, failList);
+                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                  if (fsFlag === "escalate") {
+                    messages2.push({
+                      role: "system",
+                      content: critiqueText + "\n[ESCALATED: This warning was previously issued without effect.]"
+                    });
+                  } else {
+                    this.pendingUserMessages.push(critiqueText);
+                  }
+                }
               }
             }
           }
@@ -578048,9 +578179,9 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
             const prior = this._adversaryToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.fingerprint === fingerprint && o2.turn < turn);
             if (prior) {
               this._adversaryRedundantSignals.add(fingerprint);
-              emitReaction("redundant_action", `Already ran ${name10} successfully on turn ${prior.turn}`, 0.8, prior.preview);
-              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                this.pendingUserMessages.push(buildAdversaryCritique({
+              const raFlag = adversaryFlag(`redundant_action:${fingerprint}`, messages2);
+              if (raFlag !== "suppress") {
+                const critiqueText = buildAdversaryCritique({
                   evidence: `${name10} already succeeded on turn ${prior.turn} with exact arguments (${argsKey.slice(0, 120)}). Prior preview: ${prior.preview}`,
                   hypothesis: "The main loop may have lost track of previously observed evidence because of context pressure, path confusion, or repeated discovery.",
                   correctiveAction: "Let this duplicate run execute if needed, but treat the prior result as evidence and pivot afterward unless state has changed.",
@@ -578059,13 +578190,24 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
                     "Read a different specific file or selector if the current evidence is insufficient.",
                     "Repeat exact arguments only when filesystem, browser, or page state changed."
                   ]
-                }));
+                });
+                emitReaction("redundant_action", `Already ran ${name10} successfully on turn ${prior.turn}`, 0.8, prior.preview);
+                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                  if (raFlag === "escalate") {
+                    messages2.push({
+                      role: "system",
+                      content: critiqueText + "\n[ESCALATED: This redundant-action warning was issued 3+ times as a user message without effect.]"
+                    });
+                  } else {
+                    this.pendingUserMessages.push(critiqueText);
+                  }
+                }
+                this.emit({
+                  type: "status",
+                  content: `\x1B[38;5;178m⚠ Adversary noted redundant ${name10} call (succeeded on turn ${prior.turn}); action remains allowed\x1B[0m`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
               }
-              this.emit({
-                type: "status",
-                content: `\x1B[38;5;178m⚠ Adversary noted redundant ${name10} call (succeeded on turn ${prior.turn}); action remains allowed\x1B[0m`,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
               break;
             }
           }
@@ -578083,9 +578225,9 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
               }
             }
             if (consecutiveShortResults >= 3) {
-              emitReaction("idle_think", `Consecutive output without input: ${consecutiveShortResults}`, 0.7);
-              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                this.pendingUserMessages.push(buildAdversaryCritique({
+              const itFlag = adversaryFlag("idle_think", messages2);
+              if (itFlag !== "suppress") {
+                const critiqueText = buildAdversaryCritique({
                   evidence: `${consecutiveShortResults} consecutive output-like calls occurred without an input-like observation.`,
                   hypothesis: "The loop may be acting from stale state instead of re-observing the environment.",
                   correctiveAction: "Take one input/observation step before another output step.",
@@ -578094,13 +578236,24 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
                     "Read the current UI/page state before clicking or typing again.",
                     "If the task is already complete, finish with the concrete evidence already observed."
                   ]
-                }));
+                });
+                emitReaction("idle_think", `Consecutive output without input: ${consecutiveShortResults}`, 0.7);
+                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                  if (itFlag === "escalate") {
+                    messages2.push({
+                      role: "system",
+                      content: critiqueText + "\n[ESCALATED: This warning was previously issued without effect.]"
+                    });
+                  } else {
+                    this.pendingUserMessages.push(critiqueText);
+                  }
+                }
+                this.emit({
+                  type: "status",
+                  content: `\x1B[38;5;178m⚠ Adversary flagged runaway-output risk (${consecutiveShortResults} consecutive sends without receive); action remains allowed\x1B[0m`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
               }
-              this.emit({
-                type: "status",
-                content: `\x1B[38;5;178m⚠ Adversary flagged runaway-output risk (${consecutiveShortResults} consecutive sends without receive); action remains allowed\x1B[0m`,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
             }
           }
         }
@@ -602267,7 +602420,7 @@ var init_call_agent = __esm({
       }
       /** Initialize the runner with appropriate tools for the access tier */
       async init() {
-        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey, false);
         this.backend = backend;
         const feed = getActivityFeed();
         const systemPrompt = this.buildSystemPrompt();
@@ -608597,6 +608750,8 @@ ${CONTENT_BG_SEQ}`);
         this._trueStdoutWrite.call(process.stdout, `\x1B[${scrollEnd};1H`);
         this.renderFooterAndPositionInput();
         this._trueStdoutWrite.call(process.stdout, `\x1B[${scrollEnd};1H`);
+        this._trueStdoutWrite.call(process.stdout, `
+`);
         this.termWrite("\x1B[?2026l");
         this._bufferContent = true;
       }
@@ -608966,7 +609121,18 @@ ${CONTENT_BG_SEQ}`);
         const text2 = stripped.join("\n");
         if (text2.length === 0) return;
         const ok3 = copyText(text2);
-        if (!ok3) {
+        const pos = this.rowPositions(termRows());
+        const writer = this._origWrite ?? process.stdout.write.bind(process.stdout);
+        if (ok3) {
+          if (pos.metricsRow > 0) {
+            writer(
+              `\x1B[${pos.metricsRow};1H\x1B[2K\x1B[38;5;${TEXT_PRIMARY}m  ✓ Copied session to clipboard\x1B[0m`
+            );
+          }
+          setTimeout(() => {
+            if (this.active) this.renderFooterAndPositionInput();
+          }, 1200);
+        } else {
           try {
             const fs11 = __require("fs");
             const os9 = __require("os");
@@ -608975,16 +609141,21 @@ ${CONTENT_BG_SEQ}`);
               "omnius-session-copy.txt"
             );
             fs11.writeFileSync(tmpPath, text2, "utf-8");
-            process.stderr.write(
-              `\x1B[38;5;208mClipboard unavailable — session saved to ${tmpPath}\x1B[0m
-`
-            );
+            if (pos.metricsRow > 0) {
+              writer(
+                `\x1B[${pos.metricsRow};1H\x1B[2K\x1B[38;5;208mSession saved to temp file\x1B[0m`
+              );
+            }
           } catch {
-            process.stderr.write(
-              `\x1B[38;5;196mFailed to save session to clipboard or temp file.\x1B[0m
-`
-            );
+            if (pos.metricsRow > 0) {
+              writer(
+                `\x1B[${pos.metricsRow};1H\x1B[2K\x1B[38;5;196mFailed to copy session\x1B[0m`
+              );
+            }
           }
+          setTimeout(() => {
+            if (this.active) this.renderFooterAndPositionInput();
+          }, 3e3);
         }
       }
       /**
@@ -704126,6 +704297,7 @@ ${entry.fullContent}`
       if (!liveShellBlock) return;
       liveShellBlock.repaintTimer = null;
       if (statusBar?.isActive) statusBar.refreshDisplay();
+      if (liveShellBlock.state.status === "running") scheduleLiveShellRepaint();
     }, 33);
     liveShellBlock.repaintTimer.unref?.();
   };
@@ -704227,6 +704399,7 @@ ${entry.fullContent}`
                 (width) => buildShellLiveBlockLines(state, width)
               );
               liveShellStatusBar.appendDynamicBlock(id);
+              scheduleLiveShellRepaint();
             }
           });
         }
@@ -705558,7 +705731,13 @@ Review its full output via sub_agent(action='output', id='${id}')`
             backend = new OllamaAgenticBackend(
               config.backendUrl,
               opts.model,
-              config.apiKey
+              config.apiKey,
+              // Sub-agents: force thinking OFF explicitly. Thinking models
+              // interleave <think> blocks that corrupt tool-call parsing for
+              // Qwen/Ollama. Relying on the constructor default is fragile
+              // (breaks if OMNIUS_ENABLE_THINKING=1 is inherited); pass false
+              // so sub-agent tool loops are always clean.
+              false
             );
           }
           const subTier = getModelTier(opts.model);
@@ -705595,6 +705774,10 @@ Review its full output via sub_agent(action='output', id='${id}')`
             `Sub-agent ${subAgentId}`,
             "sub"
           );
+          subRunner.onEvent((event) => {
+            const line = formatSubAgentEventForView(event);
+            if (line) statusBar.writeToAgentView(subAgentId, line);
+          });
           subRunner.registerTool(
             createTaskCompleteTool(subTier, repoRoot, true)
           );
@@ -705637,11 +705820,21 @@ ${result.summary}`
           };
         },
         spawnSubprocess: (opts) => {
-          const entry = spawnFullSubAgent(opts.task, {
-            model: opts.model,
-            backendUrl: config.backendUrl,
-            workingDir: opts.workingDir
-          });
+          const entry = spawnFullSubAgent(
+            opts.task,
+            {
+              model: opts.model,
+              backendUrl: config.backendUrl,
+              workingDir: opts.workingDir
+            },
+            // Stream the full sub-agent's stdout into its toolbar view so the
+            // clickable tab shows live output instead of staying empty.
+            (text2) => statusBar.writeToAgentView(opts.id, text2),
+            (id, exitCode) => statusBar.updateAgentViewStatus(
+              opts.id,
+              exitCode === 0 ? "completed" : "failed"
+            )
+          );
           return { id: entry.id, pid: entry.pid ?? 0 };
         },
         trackTask: (id, promise) => {

package/docs/operations/delay-fix-review.md

@@ -0,0 +1,153 @@
+# Delay Fix Review — Commits Since Delay Analysis
+
+**Date:** 2026-06-10
+**Reference:** `/docs/operations/delay-analysis.md` (15 delay sources documented)
+
+## Commit Map
+
+| Commit | Message | Files | Insertions | Date |
+|--------|---------|-------|------------|------|
+| b24bc55d | slots | 5 | +80/-18 | Jun 9 22:04 |
+| cb043dce | interactive | 11 | +865/-259 | Jun 9 21:45 |
+| ca1da293 | error catch | 12 | +389/-144 | Jun 9 10:26 |
+| 1fcdd81e | progress | 10 | +724/-19 | Jun 8 22:46 |
+
+Total: 38 files changed, ~2,058 insertions, ~440 deletions across ~4 hours.
+
+---
+
+## Delay Source Mapping — What Got Fixed
+
+### 1. `stableValueKey` — O(n) JSON.stringify on large arrays/objects (Delay #1)
+**Status: FIXED** (commit b24bc55d)
+
+Evidence from `git show b24bc55d -- packages/orchestrator/src/streaming-executor.ts`:
+```diff
+-  if (Array.isArray(value)) return `[${value.map(stableValueKey).join(",")}]`;
++  if (Array.isArray(value)) {
++    if (value.length > 256) return `[${value.length}items]`;
++    return `[${value.map(stableValueKey).join(",")}]`;
++  }
++  const raw = JSON.stringify(value);
++  if (raw.length > 10_240) {
++    let hash = 5381;
++    for (let i = 0; i < raw.length; i++)
++      hash = ((hash << 5) + hash + raw.charCodeAt(i)) | 0;
++    return `{size:${raw.length},hash:${Math.abs(hash).toString(36)}}`;
++  }
+```
+- Array length cap at 256 items prevents O(n) traversal on large arrays
+- Object size cap at 10KB prevents O(n) stringify on large objects
+- Fallback to djb2 hash for oversized objects
+- **Impact:** High — this was a core loop bottleneck in tool deduplication
+
+### 2. Tool batching / deduplication (Delay #2)
+**Status: PARTIALLY ADDRESSED** (commit b24bc55d)
+
+`tool-batching.ts` changed (+26/-18 in b24bc55d). The `stableValueKey` fix above directly addresses the dedup cost. Need to verify if batching window logic was also touched.
+
+### 3. Ollama pool / GPU detection (Delay #3, #4)
+**Status: MAJOR REWRITE** (commits cb043dce + b24bc55d)
+
+- `ollama-pool.ts`: +452/-259 in cb043dce, +35/-1 in b24bc55d
+- This is the single largest change — a full rewrite of the Ollama pool
+- The "slots" commit (b24bc55d) specifically touched ollama-pool.ts with 35 insertions
+- **Impact:** Very high — GPU detection and model loading are on the critical path
+
+### 4. Cascade backend / parallel inference (Delay #5)
+**Status: CHANGED** (commit cb043dce)
+
+`cascadeBackend.ts` changed +118/-lines in cb043dce. The "interactive" commit touched this file. Need to verify if parallel backend selection was improved.
+
+### 5. Steering intake timeout (Delay #6)
+**Status: CHANGED** (commit cb043dce)
+
+`steeringIntake.ts` changed +79/-lines in cb043dce. The "interactive" commit touched this. Need to verify timeout values.
+
+### 6. Verifier runner timeout (Delay #7)
+**Status: CHANGED** (commit b24bc55d)
+
+`verifierRunner.ts` changed +12/-lines in b24bc55d. The "slots" commit touched this.
+
+### 7. Preflight snapshot (Delay #8)
+**Status: CHANGED** (commit cb043dce)
+
+`preflightSnapshot.ts` changed +44/-lines in cb043dce.
+
+### 8. Agentic runner error handling (Delay #9)
+**Status: FIXED** (commits ca1da293 + 1fcdd81e)
+
+- ca1da293: agenticRunner.ts +102/-lines (error catch)
+- 1fcdd81e: agenticRunner.ts +28/-lines (progress)
+- Total: ~130 lines of error handling improvements
+
+### 9. Prompt caching (Delay #10)
+**Status: ADDED** (commit 1fcdd81e)
+
+`prompt-cache.ts` added (+30 lines) in commit 1fcdd81e "progress". New file for prompt caching.
+
+### 10. Context references (Delay #11)
+**Status: IMPROVED** (commit 1fcdd81e)
+
+`context-references.ts` changed +55/-lines in 1fcdd81e.
+
+### 11. TUI render / text wrapping (Delay #12)
+**Status: FIXED** (commits cb043dce + b24bc55d)
+
+- cb043dce: render.ts +44/-lines
+- b24bc55d: render.ts +13/-lines
+- Both commits touched render.ts for text rendering improvements
+
+### 12. Interactive mode (Delay #13)
+**Status: ADDED** (commit cb043dce)
+
+New file `packages/cli/src/tui/interactive.ts` (+39 lines) in cb043dce.
+
+### 13. Integration tests (Delay #14)
+**Status: ADDED** (commits ca1da293 + 1fcdd81e)
+
+- ca1da293: 4 new test files
+- 1fcdd81e: 2 new test files (agenticRunner.test.ts, prompt-caching.test.ts)
+
+### 14. Publish artifacts (Delay #15)
+**Status: UNCHANGED** (no delay-related changes)
+
+Only `publish/npm-shrinkwrap.json` and `publish/package.json` changed in working tree (uncommitted).
+
+---
+
+## Summary Assessment
+
+### Fixed / Addressed (8/15 delay sources)
+1. **stableValueKey** — fully fixed with array/object size caps
+2. **Tool deduplication** — addressed via stableValueKey fix
+3. **Ollama pool** — major rewrite (452+35 lines)
+4. **Agentic runner errors** — ~130 lines of error handling
+5. **Prompt caching** — new file added
+6. **Context references** — improved (+55 lines)
+7. **TUI render** — text wrapping fixed
+8. **Interactive mode** — new feature added
+
+### Changed but Need Verification (4/15)
+9. **Cascade backend** — +118 lines, need to verify parallel improvement
+10. **Steering intake** — +79 lines, need to verify timeout values
+11. **Verifier runner** — +12 lines, need to verify timeout values
+12. **Preflight snapshot** — +44 lines, need to verify probe timeout
+
+### Not Addressed (3/15)
+13. **Publish artifacts** — no delay-related changes
+14. **Integration tests** — added but not a delay fix per se
+15. **Working tree state** — only publish files changed (uncommitted)
+
+### Overall Assessment
+- **~53% of delay sources addressed** (8/15 fixed, 4/15 changed pending verification)
+- The "slots" commit (b24bc55d) is the most recent and focused on core loop fixes
+- The "interactive" commit (cb043dce) is the largest and touched the most files
+- **Key gap:** Need to verify the actual timeout values in cascadeBackend.ts, steeringIntake.ts, and verifierRunner.ts to confirm the changes actually reduce delays
+- **Key gap:** The working tree has 2 uncommitted changes in publish/ — need to check if these are relevant
+
+### Recommended Next Steps
+1. Verify timeout values in cascadeBackend.ts, steeringIntake.ts, verifierRunner.ts
+2. Check if ollama-pool.ts rewrite includes GPU detection improvements
+3. Verify the working tree changes in publish/ are intentional
+4. Run the build to ensure all changes compile cleanly

package/npm-shrinkwrap.json

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

package/package.json

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