omnius 1.0.268 → 1.0.270

package/dist/index.js

@@ -554725,7 +554725,7 @@ var init_verifierRunner = __esm({
               continue;
             const { stdout, stderr } = await execFileAsync5(bin, args, {
               cwd: workDir,
-              timeout: 6e4,
+              timeout: 15e3,
               maxBuffer: 1024 * 1024
             });
             outputs.push(`$ ${cmd}
@@ -557139,6 +557139,23 @@ var init_ollama_pool = __esm({
         scored.sort((a2, b) => b.score - a2.score);
         return scored[0].inst;
       }
+      _lastEagerCleanup = 0;
+      triggerEagerCleanup() {
+        if (process.env["NODE_ENV"] === "test" || process.env["VITEST"])
+          return;
+        const now2 = Date.now();
+        if (now2 - this._lastEagerCleanup < 5e3)
+          return;
+        this._lastEagerCleanup = now2;
+        Promise.resolve().then(() => (init_ollama_pool_cleanup(), ollama_pool_cleanup_exports)).then((mod3) => mod3.cleanupStaleOllamaProcesses({
+          dryRun: false,
+          useInference: "auto",
+          baseInstanceUrl: this.config.baseInstanceUrl,
+          poolPortStart: this.config.spawnPortStart,
+          poolStatus: null
+        })).catch(() => {
+        });
+      }
       buildSlot(inst, agentId) {
         return {
           instanceId: inst.state.id,
@@ -557151,6 +557168,7 @@ var init_ollama_pool = __esm({
           release: (success) => {
             inst.release(success);
             this.wakeNextSlotWaiter();
+            this.triggerEagerCleanup();
           }
         };
       }
@@ -557163,7 +557181,13 @@ var init_ollama_pool = __esm({
               this.recordAffinity(agentId, pick.state.id);
             return this.buildSlot(pick, agentId);
           }
-          await new Promise((resolve70) => this.slotWaiters.push(resolve70));
+          await new Promise((resolve70, reject) => {
+            const timer = setTimeout(() => reject(new Error("No GPU slot available after 30s. All slots occupied.")), 3e4);
+            this.slotWaiters.push(() => {
+              clearTimeout(timer);
+              resolve70();
+            });
+          });
         }
       }
       wakeNextSlotWaiter() {
@@ -561875,7 +561899,7 @@ function partitionToolCalls(calls, readOnlyHints) {
   }
   return batches;
 }
-async function withConcurrencyLimit(fns, limit = 5) {
+async function withConcurrencyLimit(fns, limit = 8) {
   const results = new Array(fns.length);
   let nextIdx = 0;
   async function runNext() {
@@ -561888,7 +561912,7 @@ async function withConcurrencyLimit(fns, limit = 5) {
   await Promise.all(workers);
   return results;
 }
-async function executeBatch(batch2, executeFn, concurrencyLimit = 5) {
+async function executeBatch(batch2, executeFn, concurrencyLimit = 8) {
   if (!batch2.concurrent || batch2.calls.length === 1) {
     const results = [];
     for (const call of batch2.calls) {
@@ -562501,8 +562525,18 @@ var init_app_state = __esm({
 function stableValueKey(value2) {
   if (value2 === null || typeof value2 !== "object")
     return JSON.stringify(value2);
-  if (Array.isArray(value2))
+  if (Array.isArray(value2)) {
+    if (value2.length > 256)
+      return `[${value2.length}items]`;
     return `[${value2.map(stableValueKey).join(",")}]`;
+  }
+  const raw = JSON.stringify(value2);
+  if (raw.length > 10240) {
+    let hash = 5381;
+    for (let i2 = 0; i2 < raw.length; i2++)
+      hash = (hash << 5) + hash + raw.charCodeAt(i2) | 0;
+    return `{size:${raw.length},hash:${Math.abs(hash).toString(36)}}`;
+  }
   const record = value2;
   return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableValueKey(record[key])}`).join(",")}}`;
 }
@@ -565415,7 +565449,7 @@ var init_agenticRunner = __esm({
       "repl_exec",
       "notebook_edit"
     ]);
-    AgenticRunner = class {
+    AgenticRunner = class _AgenticRunner {
       backend;
       tools = /* @__PURE__ */ new Map();
       options;
@@ -570622,6 +570656,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 = [];
@@ -574769,7 +574804,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();
@@ -577862,6 +577896,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. */
@@ -577924,6 +577965,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",
@@ -577951,9 +578009,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.",
@@ -577962,13 +578020,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()
-              });
             }
           }
         }
@@ -577981,9 +578050,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.",
@@ -577992,7 +578061,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);
+                  }
+                }
               }
             }
           }
@@ -578014,9 +578094,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.",
@@ -578025,13 +578105,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;
             }
           }
@@ -578049,9 +578140,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.",
@@ -578060,13 +578151,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()
-              });
             }
           }
         }
@@ -595676,6 +595778,20 @@ function buildToolDivider(width, colorCode) {
   const border = toolColorSeq(colorCode);
   return `${border}${BOX_TJ_L2}${BOX_H2.repeat(Math.max(0, width - 2))}${BOX_TJ_R2}${toolResetSeq()}`;
 }
+function buildRoutingHeader(title, _metrics, width, colorCode, _metricsColorCode = 222) {
+  const border = toolColorSeq(colorCode);
+  const titleColor = toolColorSeq(colorCode, true);
+  const reset = toolResetSeq();
+  const w = Math.max(40, width);
+  const titleVisible = stripAnsi(title);
+  const titleChip = ` ${titleVisible} `;
+  const shortBoxWidth = titleChip.length + 7;
+  const line1 = `${border}${BOX_TL2}${BOX_H2}${border}${BOX_TJ_L2}${titleColor}${titleChip}${reset}${border}${BOX_TJ_R2}${BOX_H2}${BOX_H2}${BOX_TR2}${reset}`;
+  const gap = Math.max(0, shortBoxWidth - 1);
+  const dashCount = Math.max(0, w - shortBoxWidth - 2);
+  const line2 = `${border}${BOX_TJ_L2}${reset}` + " ".repeat(gap) + `${border}╰${BOX_H2.repeat(dashCount)}${BOX_TJ_R2}${reset}`;
+  return [line1, line2];
+}
 function buildToolBottom(width, colorCode) {
   const border = toolColorSeq(colorCode);
   return `${border}${BOX_BL2}${BOX_H2.repeat(Math.max(0, width - 2))}${BOX_BR2}${toolResetSeq()}`;
@@ -595821,26 +595937,38 @@ function buildCombinedToolBoxLines(toolName, callArgs, success, output, opts, wi
     { label: "Provenance", items: provenance }
   ];
   const colorCode = success ? toolColorCode(toolName) : TOOL_ERROR_COLOR_CODE;
-  const lines = [
-    buildToolTopBorder(
+  const triggerTexts = formatToolArgsForBox(toolName, callArgs, opts.verbose);
+  const lines = [];
+  if (triggerTexts.length === 0) {
+    const [r1, r2] = buildRoutingHeader(
       `${status} ${label}`,
       metrics2,
       w,
       colorCode,
       success ? void 0 : TOOL_ERROR_COLOR_CODE
-    )
-  ];
-  const triggerTexts = formatToolArgsForBox(toolName, callArgs, opts.verbose);
-  for (const text2 of triggerTexts) {
-    const pipe3 = "  ";
-    const chunks = wrapToolTextLine(text2, innerWidth, pipe3);
-    for (const chunk of chunks) {
-      lines.push(
-        buildToolContentRow(formatToolBoxLine(chunk, "tool"), w, colorCode)
-      );
+    );
+    lines.push(r1, r2);
+  } else {
+    lines.push(
+      buildToolTopBorder(
+        `${status} ${label}`,
+        metrics2,
+        w,
+        colorCode,
+        success ? void 0 : TOOL_ERROR_COLOR_CODE
+      )
+    );
+    for (const text2 of triggerTexts) {
+      const pipe3 = "  ";
+      const chunks = wrapToolTextLine(text2, innerWidth, pipe3);
+      for (const chunk of chunks) {
+        lines.push(
+          buildToolContentRow(formatToolBoxLine(chunk, "tool"), w, colorCode)
+        );
+      }
     }
+    lines.push(buildToolDivider(w, colorCode));
   }
-  lines.push(buildToolDivider(w, colorCode));
   if (resultBody.length > 0) {
     for (const bodyLine of resultBody) {
       const text2 = sanitizeToolBoxContent(bodyLine.text);
@@ -596212,11 +596340,22 @@ function buildToolResultBody(toolName, success, output, verbose) {
   }
   if (toolName === "task_complete") {
     const summary = output && output.trim() ? output : "Done";
-    return summary.split("\n").map((line) => ({
+    const maxLines2 = resolveToolOutputMaxLines(verbose);
+    const lines = summary.split("\n");
+    const body = lines.slice(0, maxLines2).map((line) => ({
       text: line,
       mode: "wrap",
       kind: "markdown"
     }));
+    const remaining = lines.length - maxLines2;
+    if (remaining > 0) {
+      body.push({
+        text: `... ${remaining} more lines`,
+        mode: "wrap",
+        kind: "dim"
+      });
+    }
+    return body;
   }
   const filtered = output.split("\n").map(sanitizeToolBoxContent).map((line) => debug ? line : stripTrustTierWrapperForTui(line)).filter((line) => {
     const trimmed = line.trim();
@@ -608526,6 +608665,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;
       }
@@ -608895,7 +609036,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");
@@ -608904,16 +609056,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);
         }
       }
       /**
@@ -645422,6 +645579,23 @@ function italicText(text2) {
 function dimItalic(text2) {
   return isTTY8 ? `\x1B[3m\x1B[38;5;${tuiTextDim()}m${text2}\x1B[0m` : text2;
 }
+function thinkingBoxTop(width) {
+  const inner = Math.max(4, width);
+  const title = " Processing ";
+  return `╭─┤${title}├${"─".repeat(Math.max(0, inner - 6 - title.length))}╮`;
+}
+function thinkingBoxRow(text2, width) {
+  const inner = Math.max(1, width - 4);
+  const plain = stripAnsi(text2);
+  const truncated = plain.length > inner ? plain.slice(0, Math.max(1, inner - 1)) + "…" : text2;
+  const plainLen = stripAnsi(truncated).length;
+  const padding = " ".repeat(Math.max(0, inner - plainLen));
+  return `│ ${truncated}${padding} │`;
+}
+function thinkingBoxBottom(width) {
+  const inner = Math.max(4, width);
+  return `╰${"─".repeat(inner - 2)}╯`;
+}
 function boldText(text2) {
   return isTTY8 ? `\x1B[1m${text2}\x1B[0m` : text2;
 }
@@ -645547,6 +645721,9 @@ var init_stream_renderer = __esm({
       thinkingIndicatorShown = false;
       thinkingTokenCount = 0;
       thinkingCache = "";
+      /** Thinking box — compact bordered box for the thinking indicator */
+      thinkingBoxOpen = false;
+      thinkingBoxRowCount = 0;
       write(token, kind) {
         if (!this.enabled) return;
         this.tokenCount++;
@@ -645554,6 +645731,9 @@ var init_stream_renderer = __esm({
           this.thinkingTokenCount++;
           if (token && !this.showThinking) this.thinkingCache += token;
           if (this.showThinking) {
+            if (this.thinkingBoxOpen) {
+              this.closeThinkingBox(`buffered ${this.thinkingTokenCount} tokens`);
+            }
             for (const char of token) {
               this.lineBuffer += char;
               if (char === "\n") this.flushLine("thinking");
@@ -645561,23 +645741,26 @@ var init_stream_renderer = __esm({
             this.scheduleFlush("thinking");
             return;
           } else {
-            if (!this.thinkingIndicatorShown) {
-              this.thinkingIndicatorShown = true;
-              this.writeRaw(dimText("  │  ") + dimItalic("thinking...") + "\n");
+            const w = termCols();
+            if (!this.thinkingBoxOpen) {
+              this.thinkingBoxOpen = true;
+              this.thinkingBoxRowCount = 2;
+              this.writeRaw(thinkingBoxTop(w) + "\n");
+              this.writeRaw(thinkingBoxRow(dimItalic("processing..."), w) + "\n");
               this.lineStarted = false;
             }
             if (this.thinkingTokenCount % 500 === 0) {
-              this.writeRaw(dimText("  │  ") + dimItalic(`thinking... (${this.thinkingTokenCount} tokens)`) + "\n");
-              this.lineStarted = false;
+              this.updateThinkingBox(
+                `processing... (${this.thinkingTokenCount} tokens)`,
+                w
+              );
             }
             return;
           }
         }
-        if (this.thinkingIndicatorShown && kind === "content") {
-          this.thinkingIndicatorShown = false;
-          this.writeRaw(dimText("  │  ") + dimItalic(`thought for ${this.thinkingTokenCount} tokens`) + "\n");
+        if (this.thinkingBoxOpen && kind === "content") {
+          this.closeThinkingBox(`thought for ${this.thinkingTokenCount} tokens`);
           this.thinkingTokenCount = 0;
-          this.lineStarted = false;
         }
         if (kind === "tool_args" && !this.inToolArgs) {
           this.flushPartial(kind);
@@ -645603,6 +645786,9 @@ var init_stream_renderer = __esm({
           this.writeHighlighted(this.lineBuffer, kind);
           this.lineBuffer = "";
         }
+        if (this.thinkingBoxOpen) {
+          this.closeThinkingBox(`processed ${this.thinkingTokenCount} tokens`);
+        }
         if (this.lineStarted) {
           process.stdout.write("\n");
           this.lineStarted = false;
@@ -645636,7 +645822,11 @@ var init_stream_renderer = __esm({
         if (line.includes("<think>")) {
           this.inThinkBlock = true;
           const after = line.replace(/<think>/g, "");
-          if (after.trim()) this.writeHighlighted(after, this.showThinking ? "thinking" : "content");
+          if (after.trim())
+            this.writeHighlighted(
+              after,
+              this.showThinking ? "thinking" : "content"
+            );
           return;
         }
         if (line.includes("</think>")) {
@@ -645723,7 +645913,9 @@ var init_stream_renderer = __esm({
             const isLast = i2 === lines.length - 1;
             const lp = isFirst ? usePrefix : "     ";
             const needsNewline = !isLast || trailingNewline;
-            this.writeRaw(dimText(lp) + highlight(lines[i2]) + (needsNewline ? "\n" : ""));
+            this.writeRaw(
+              dimText(lp) + highlight(lines[i2]) + (needsNewline ? "\n" : "")
+            );
           }
           this.lineStarted = !trailingNewline;
         };
@@ -645767,10 +645959,33 @@ var init_stream_renderer = __esm({
         this.writeRaw(dimText(prefix) + rendered + (hasNewline ? "\n" : ""));
         this.lineStarted = !hasNewline;
       }
+      /** In-place update of the compact thinking box content row (cursor-up + rewrite) */
+      updateThinkingBox(text2, width) {
+        if (!this.thinkingBoxOpen) return;
+        const update2 = `\x1B[${this.thinkingBoxRowCount}A` + thinkingBoxTop(width) + "\n" + thinkingBoxRow(dimItalic(text2), width) + "\n";
+        this.writeRaw(update2);
+        this.lineStarted = false;
+      }
+      /** Close the compact thinking box (cursor-up, rewrite with summary + bottom border) */
+      closeThinkingBox(summary) {
+        if (!this.thinkingBoxOpen) return;
+        const w = termCols();
+        const text2 = `\x1B[${this.thinkingBoxRowCount}A` + thinkingBoxTop(w) + "\n" + thinkingBoxRow(dimItalic(summary), w) + "\n" + thinkingBoxBottom(w) + "\n";
+        this.writeRaw(text2);
+        this.thinkingBoxOpen = false;
+        this.thinkingBoxRowCount = 0;
+        this.lineStarted = false;
+        this.thinkingIndicatorShown = false;
+      }
       /** Toggle visibility of full thinking content */
       setThinkingVisible(visible) {
         this.showThinking = visible;
-        if (visible) this.thinkingCache = "";
+        if (visible) {
+          if (this.thinkingBoxOpen) {
+            this.closeThinkingBox(`buffered ${this.thinkingTokenCount} tokens`);
+          }
+          this.thinkingCache = "";
+        }
       }
       /** Emit the cached (pre-toggle) thinking content to stdout as dim italic
        * lines. Uses writeRaw so _cursorCol / lineStarted tracking stays in sync
@@ -645875,7 +646090,8 @@ var init_stream_renderer = __esm({
       looksLikeJsonBlob(text2) {
         if (/\\u[0-9a-fA-F]{4}/.test(text2)) return true;
         if (/^\s*\{?"content"\s*:/.test(text2)) return true;
-        if (text2.includes("\\n") && this.looksLikeJson(text2) && text2.length > 100) return true;
+        if (text2.includes("\\n") && this.looksLikeJson(text2) && text2.length > 100)
+          return true;
         return false;
       }
       /**
@@ -645886,12 +646102,30 @@ var init_stream_renderer = __esm({
         const colorKey = dim ? PASTEL.toolArg : PASTEL.key;
         const colorStr = dim ? PASTEL.toolArg : PASTEL.string;
         let result = line;
-        result = result.replace(/"([^"]*)"(\s*:)/g, (_m, key, colon) => fg2564(colorKey, `"${key}"`) + fg2564(PASTEL.colon, colon));
-        result = result.replace(/(:\s*)"([^"]*)"/g, (_m, prefix, val) => fg2564(PASTEL.colon, prefix) + fg2564(colorStr, `"${val}"`));
-        result = result.replace(/(:\s*)(\d+\.?\d*)/g, (_m, prefix, num2) => fg2564(PASTEL.colon, prefix) + fg2564(PASTEL.number, num2));
-        result = result.replace(/(:\s*)(true|false)/g, (_m, prefix, bool) => fg2564(PASTEL.colon, prefix) + fg2564(PASTEL.boolean, bool));
-        result = result.replace(/(:\s*)(null)/g, (_m, prefix, n2) => fg2564(PASTEL.colon, prefix) + fg2564(PASTEL.null, n2));
-        result = result.replace(/([{}[\]])/g, (_m, b) => fg2564(PASTEL.bracket, b));
+        result = result.replace(
+          /"([^"]*)"(\s*:)/g,
+          (_m, key, colon) => fg2564(colorKey, `"${key}"`) + fg2564(PASTEL.colon, colon)
+        );
+        result = result.replace(
+          /(:\s*)"([^"]*)"/g,
+          (_m, prefix, val) => fg2564(PASTEL.colon, prefix) + fg2564(colorStr, `"${val}"`)
+        );
+        result = result.replace(
+          /(:\s*)(\d+\.?\d*)/g,
+          (_m, prefix, num2) => fg2564(PASTEL.colon, prefix) + fg2564(PASTEL.number, num2)
+        );
+        result = result.replace(
+          /(:\s*)(true|false)/g,
+          (_m, prefix, bool) => fg2564(PASTEL.colon, prefix) + fg2564(PASTEL.boolean, bool)
+        );
+        result = result.replace(
+          /(:\s*)(null)/g,
+          (_m, prefix, n2) => fg2564(PASTEL.colon, prefix) + fg2564(PASTEL.null, n2)
+        );
+        result = result.replace(
+          /([{}[\]])/g,
+          (_m, b) => fg2564(PASTEL.bracket, b)
+        );
         return dim ? dimText(result) : result;
       }
       /**
@@ -645899,16 +646133,34 @@ var init_stream_renderer = __esm({
        */
       highlightCode(line) {
         let result = line;
-        result = result.replace(/"([^"]*)"/g, (_m, s2) => fg2564(PASTEL.string, `"${s2}"`));
-        result = result.replace(/'([^']*)'/g, (_m, s2) => fg2564(PASTEL.string, `'${s2}'`));
-        result = result.replace(/\b(\d+\.?\d*)\b/g, (_m, n2) => fg2564(PASTEL.number, n2));
-        result = result.replace(/\b(true|false|null|undefined|None|True|False)\b/g, (_m, kw) => fg2564(PASTEL.boolean, kw));
+        result = result.replace(
+          /"([^"]*)"/g,
+          (_m, s2) => fg2564(PASTEL.string, `"${s2}"`)
+        );
+        result = result.replace(
+          /'([^']*)'/g,
+          (_m, s2) => fg2564(PASTEL.string, `'${s2}'`)
+        );
+        result = result.replace(
+          /\b(\d+\.?\d*)\b/g,
+          (_m, n2) => fg2564(PASTEL.number, n2)
+        );
+        result = result.replace(
+          /\b(true|false|null|undefined|None|True|False)\b/g,
+          (_m, kw) => fg2564(PASTEL.boolean, kw)
+        );
         result = result.replace(
           /\b(function|const|let|var|return|if|else|for|while|import|export|from|class|async|await|def|self|try|catch|finally|throw|new|typeof|instanceof|type|interface|enum|struct|impl|fn|pub|mod|use|match|trait|where|mut|ref|move|yield|switch|case|default|break|continue|do|in|of|extends|implements|super|this|static|abstract|override|readonly|declare|namespace|package|func|go|chan|select|defer|range|map)\b/g,
           (_m, kw) => fg2564(PASTEL.keyword, kw)
         );
-        result = result.replace(/:\s*([A-Z]\w*)/g, (_m, t2) => ": " + fg2564(147, t2));
-        result = result.replace(/(\/\/.*$|#.*$)/gm, (_m, cm) => fg2564(PASTEL.comment, cm));
+        result = result.replace(
+          /:\s*([A-Z]\w*)/g,
+          (_m, t2) => ": " + fg2564(147, t2)
+        );
+        result = result.replace(
+          /(\/\/.*$|#.*$)/gm,
+          (_m, cm) => fg2564(PASTEL.comment, cm)
+        );
         return result;
       }
       // -------------------------------------------------------------------------
@@ -645956,16 +646208,34 @@ var init_stream_renderer = __esm({
           return fg2564(PASTEL.comment, line);
         }
         let result = line;
-        result = result.replace(/"([^"]*)"/g, (_m, s2) => fg2564(PASTEL.string, `"${s2}"`));
-        result = result.replace(/'([^']*)'/g, (_m, s2) => fg2564(PASTEL.string, `'${s2}'`));
-        result = result.replace(/(\$\{[^}]+\}|\$[A-Za-z_]\w*|\$[0-9?@#*!$-])/g, (_m, v) => fg2564(PASTEL.shellVar, v));
-        result = result.replace(/((?:^|\s))(--?[a-zA-Z][\w-]*)/g, (_m, ws, flag) => ws + fg2564(PASTEL.shellFlag, flag));
-        result = result.replace(/(\|{1,2}|>{1,2}|<{1,2}|&{1,2}|;)/g, (_m, op) => fg2564(PASTEL.shellOp, op));
+        result = result.replace(
+          /"([^"]*)"/g,
+          (_m, s2) => fg2564(PASTEL.string, `"${s2}"`)
+        );
+        result = result.replace(
+          /'([^']*)'/g,
+          (_m, s2) => fg2564(PASTEL.string, `'${s2}'`)
+        );
+        result = result.replace(
+          /(\$\{[^}]+\}|\$[A-Za-z_]\w*|\$[0-9?@#*!$-])/g,
+          (_m, v) => fg2564(PASTEL.shellVar, v)
+        );
+        result = result.replace(
+          /((?:^|\s))(--?[a-zA-Z][\w-]*)/g,
+          (_m, ws, flag) => ws + fg2564(PASTEL.shellFlag, flag)
+        );
+        result = result.replace(
+          /(\|{1,2}|>{1,2}|<{1,2}|&{1,2}|;)/g,
+          (_m, op) => fg2564(PASTEL.shellOp, op)
+        );
         result = result.replace(
           /^(\s*)(npm|npx|node|pnpm|yarn|git|docker|kubectl|curl|wget|cat|grep|find|ls|cd|cp|mv|rm|mkdir|chmod|chown|echo|printf|sed|awk|sort|uniq|head|tail|wc|tar|gzip|make|cargo|go|pip|python|python3|ruby|gem|brew|apt|yum|dnf|pacman|sudo|ssh|scp|rsync|man)\b/,
           (_m, ws, cmd) => ws + boldText(fg2564(PASTEL.keyword, cmd))
         );
-        result = result.replace(/(#[^{].*$)/gm, (_m, cm) => fg2564(PASTEL.comment, cm));
+        result = result.replace(
+          /(#[^{].*$)/gm,
+          (_m, cm) => fg2564(PASTEL.comment, cm)
+        );
         return result;
       }
       // -------------------------------------------------------------------------
@@ -645979,7 +646249,14 @@ var init_stream_renderer = __esm({
         if (headingMatch) {
           const level = headingMatch[1].length;
           const text2 = headingMatch[2];
-          const colors2 = [PASTEL.heading1, PASTEL.heading2, PASTEL.heading3, PASTEL.heading3, 183, 183];
+          const colors2 = [
+            PASTEL.heading1,
+            PASTEL.heading2,
+            PASTEL.heading3,
+            PASTEL.heading3,
+            183,
+            183
+          ];
           return boldText(fg2564(colors2[level - 1] ?? 147, text2));
         }
         if (/^[-*_]{3,}\s*$/.test(line)) {
@@ -646005,13 +646282,34 @@ var init_stream_renderer = __esm({
        */
       highlightInline(text2) {
         let result = text2;
-        result = result.replace(/`([^`]+)`/g, (_m, code8) => fg2564(PASTEL.inlineCode, code8));
-        result = result.replace(/\*{3}([^*]+)\*{3}/g, (_m, t2) => boldText(italicText(t2)));
-        result = result.replace(/\*{2}([^*]+)\*{2}/g, (_m, t2) => boldText(t2));
-        result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_m, t2) => italicText(t2));
-        result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, label, url) => boldText(fg2564(PASTEL.link, label)) + " " + dimText(fg2564(PASTEL.link, `(${url})`)));
-        result = result.replace(/(?<!\w)__([^_]+)__(?!\w)/g, (_m, t2) => boldText(t2));
-        result = result.replace(/(?<!\w)_([^_]+)_(?!\w)/g, (_m, t2) => italicText(t2));
+        result = result.replace(
+          /`([^`]+)`/g,
+          (_m, code8) => fg2564(PASTEL.inlineCode, code8)
+        );
+        result = result.replace(
+          /\*{3}([^*]+)\*{3}/g,
+          (_m, t2) => boldText(italicText(t2))
+        );
+        result = result.replace(
+          /\*{2}([^*]+)\*{2}/g,
+          (_m, t2) => boldText(t2)
+        );
+        result = result.replace(
+          /(?<!\*)\*([^*]+)\*(?!\*)/g,
+          (_m, t2) => italicText(t2)
+        );
+        result = result.replace(
+          /\[([^\]]+)\]\(([^)]+)\)/g,
+          (_m, label, url) => boldText(fg2564(PASTEL.link, label)) + " " + dimText(fg2564(PASTEL.link, `(${url})`))
+        );
+        result = result.replace(
+          /(?<!\w)__([^_]+)__(?!\w)/g,
+          (_m, t2) => boldText(t2)
+        );
+        result = result.replace(
+          /(?<!\w)_([^_]+)_(?!\w)/g,
+          (_m, t2) => italicText(t2)
+        );
         result = result.replace(/~~([^~]+)~~/g, (_m, t2) => dimText(t2));
         return result;
       }
@@ -703914,6 +704212,7 @@ ${entry.fullContent}`
       if (!liveShellBlock) return;
       liveShellBlock.repaintTimer = null;
       if (statusBar?.isActive) statusBar.refreshDisplay();
+      if (liveShellBlock.state.status === "running") scheduleLiveShellRepaint();
     }, 33);
     liveShellBlock.repaintTimer.unref?.();
   };
@@ -704015,6 +704314,7 @@ ${entry.fullContent}`
                 (width) => buildShellLiveBlockLines(state, width)
               );
               liveShellStatusBar.appendDynamicBlock(id);
+              scheduleLiveShellRepaint();
             }
           });
         }

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.268",
+  "version": "1.0.270",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.268",
+      "version": "1.0.270",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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