omnius 1.0.545 → 1.0.546

package/dist/index.js

@@ -5195,6 +5195,18 @@ ${result.llmContent ?? ""}`);
             llmContent: this.markTranscriptFailure(result.llmContent ?? result.output ?? "", reportedExitCode, error)
           };
         }
+        if (result.success && process.env["OMNIUS_DISABLE_SOFT_FAILURE_DETECT"] !== "1") {
+          const declared = this.terminalErrorDeclarationFromOutput(command, result.output ?? "");
+          if (declared) {
+            const error = `Command exited 0 but its final output declares an error: "${declared.slice(0, 160)}". The probe did NOT achieve its goal — treat this as a failure, not a success. Do not re-run the same command unchanged; change the approach or the arguments.`;
+            result = {
+              ...result,
+              success: false,
+              error,
+              llmContent: this.markSoftFailureTranscript(result.llmContent ?? result.output ?? "", error)
+            };
+          }
+        }
         if (this.isBenignPipePreviewSigpipe(command, result)) {
           const note = "[NOTE — preview pipe closed after producing output]\nA downstream preview command such as `head`/`tail`/`sed -n` closed the pipe early, producing SIGPIPE exit 141 upstream. Captured output is usable as a preview; rerun without the preview pipe if the full output is needed.";
           const output = result.output ? `${result.output}
@@ -5286,6 +5298,55 @@ ${elevatedResult.stderr}` : ""),
         }
         return found;
       }
+      /**
+       * Detect an unambiguous error declaration on the FINAL line(s) of a
+       * command's output despite exit 0 (false-success probe). Conservative:
+       * anchored patterns, last two non-empty lines only, and skipped entirely
+       * for pure search/read commands (grep/rg/cat/…) whose output legitimately
+       * QUOTES error text. Returns the declaring line, or null.
+       */
+      terminalErrorDeclarationFromOutput(command, output) {
+        if (/^\s*(?:grep|rg|ag|cat|head|tail|less|awk|sed|find|ls|wc|sort|uniq|diff|strings|hexdump|xxd|jq|yq)\b/.test(command)) {
+          return null;
+        }
+        const lines = output.split("\n").map((l2) => l2.trim()).filter((l2) => l2.length > 0 && !l2.startsWith("["));
+        if (lines.length === 0)
+          return null;
+        const tail = lines.slice(-2);
+        const TERMINAL_ERROR = [
+          /^ERROR\b[:\s]/,
+          // conventional script error prefix (screenshot case: "ERROR: timed out")
+          /^FAILED\b/,
+          /^FAILURE\b[:\s]/,
+          /^FATAL\b[:\s]/i,
+          /^[A-Za-z_][A-Za-z0-9_.]*(?:Error|Exception)\b:/,
+          // Python traceback terminal line
+          /^panic:/,
+          // Go
+          /^Segmentation fault\b/
+        ];
+        for (let i2 = tail.length - 1; i2 >= 0; i2--) {
+          const line = tail[i2];
+          if (TERMINAL_ERROR.some((re) => re.test(line)))
+            return line;
+        }
+        return null;
+      }
+      /**
+       * Rewrite a transcript for a false-success probe: status becomes failure
+       * while the true wrapper exit code (0) stays visible, so the model sees
+       * BOTH facts — the process exited cleanly AND the operation failed.
+       */
+      markSoftFailureTranscript(text2, error) {
+        if (!text2)
+          return error;
+        let next = text2.replace(/status: success/g, "status: failure (error declared in output despite exit 0)");
+        if (!next.includes(error)) {
+          next = `${next}
+error: ${error}`;
+        }
+        return next;
+      }
       markTranscriptFailure(text2, exitCode, error) {
         if (!text2)
           return error;
@@ -566130,6 +566191,165 @@ var init_textSanitize = __esm({
   }
 });
 
+// packages/orchestrator/dist/text-echo-guard.js
+function normalizeForEcho(text2) {
+  return text2.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<reasoning>[\s\S]*?<\/reasoning>/gi, "").replace(/```[\s\S]*?```/g, " ").replace(/[*_`#>|-]+/g, " ").toLowerCase().replace(/\s+/g, " ").trim();
+}
+function echoSimilarity(a2, b) {
+  const sa = shingles(a2);
+  const sb = shingles(b);
+  if (sa.size === 0 || sb.size === 0) {
+    return a2 === b && a2.length > 0 ? 1 : 0;
+  }
+  let inter = 0;
+  for (const s2 of sa)
+    if (sb.has(s2))
+      inter++;
+  const union = sa.size + sb.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+function shingles(normalized, k = 3) {
+  const words = normalized.split(" ").filter(Boolean);
+  const out = /* @__PURE__ */ new Set();
+  for (let i2 = 0; i2 + k <= words.length; i2++) {
+    out.add(words.slice(i2, i2 + k).join(" "));
+  }
+  return out;
+}
+function contentAsText(m2) {
+  if (typeof m2.content === "string")
+    return m2.content;
+  return null;
+}
+function isEligible(m2, minLength) {
+  if (m2.role !== "assistant")
+    return false;
+  if (Array.isArray(m2.tool_calls) && m2.tool_calls.length > 0)
+    return false;
+  const text2 = contentAsText(m2);
+  if (!text2)
+    return false;
+  if (text2.startsWith(COLLAPSE_MARKER))
+    return false;
+  return normalizeForEcho(text2).length >= minLength;
+}
+var COLLAPSE_MARKER, DEFAULTS, TextEchoGuard;
+var init_text_echo_guard = __esm({
+  "packages/orchestrator/dist/text-echo-guard.js"() {
+    "use strict";
+    COLLAPSE_MARKER = "[Superseded near-duplicate plan removed";
+    DEFAULTS = {
+      similarityThreshold: 0.6,
+      minLength: 80,
+      window: 6
+    };
+    TextEchoGuard = class {
+      threshold;
+      minLength;
+      window;
+      /** Recent normalized text-only assistant messages (raw preview kept for messaging). */
+      recent = [];
+      streak = 0;
+      constructor(options2 = {}) {
+        this.threshold = options2.similarityThreshold ?? DEFAULTS.similarityThreshold;
+        this.minLength = options2.minLength ?? DEFAULTS.minLength;
+        this.window = options2.window ?? DEFAULTS.window;
+      }
+      /**
+       * Observe a new text-only assistant message. Records it and reports whether
+       * it echoes a recent one. Call ONLY for text-only turns (no tool_calls).
+       */
+      observe(text2) {
+        const normalized = normalizeForEcho(text2);
+        if (normalized.length < this.minLength) {
+          return { isEcho: false, echoCount: this.streak, similarity: 0, matchedPreview: "" };
+        }
+        let best = 0;
+        let matchedPreview = "";
+        for (const prev of this.recent) {
+          const sim = echoSimilarity(normalized, prev.normalized);
+          if (sim > best) {
+            best = sim;
+            matchedPreview = prev.preview;
+          }
+        }
+        const isEcho = best >= this.threshold;
+        this.streak = isEcho ? this.streak + 1 : 0;
+        this.recent.push({ normalized, preview: text2.slice(0, 160) });
+        if (this.recent.length > this.window)
+          this.recent.shift();
+        return {
+          isEcho,
+          echoCount: this.streak,
+          similarity: best,
+          matchedPreview
+        };
+      }
+      /** A real tool call happened — the loop is broken; reset escalation. */
+      noteToolProgress() {
+        this.streak = 0;
+      }
+      /**
+       * Remove the attractor from the live prompt: for every pair of text-only
+       * assistant messages where an EARLIER one is a near-duplicate of a LATER
+       * one, replace the earlier one's content with a one-line stub. The latest
+       * copy always survives. Safe to call repeatedly (stubs are skipped).
+       *
+       * Returns the number of messages collapsed.
+       */
+      collapseEchoes(messages2) {
+        const eligible = [];
+        for (let i2 = 0; i2 < messages2.length; i2++) {
+          const m2 = messages2[i2];
+          if (isEligible(m2, this.minLength)) {
+            eligible.push({ idx: i2, normalized: normalizeForEcho(m2.content) });
+          }
+        }
+        if (eligible.length < 2)
+          return 0;
+        let collapsed = 0;
+        const survivors = [];
+        for (let j = eligible.length - 1; j >= 0; j--) {
+          const cur = eligible[j];
+          const echoesSurvivor = survivors.some((s2) => echoSimilarity(cur.normalized, s2) >= this.threshold);
+          if (echoesSurvivor) {
+            const msg = messages2[cur.idx];
+            const preview = (contentAsText(msg) ?? "").slice(0, 100).replace(/\s+/g, " ");
+            msg.content = `${COLLAPSE_MARKER} — an almost identical statement appears later in this conversation ("${preview}…"). No tool call followed it. Do NOT restate this plan; execute its next step with a tool call.]`;
+            collapsed++;
+          } else {
+            survivors.push(cur.normalized);
+          }
+        }
+        return collapsed;
+      }
+      /**
+       * Escalating pattern-breaker to inject INSTEAD of the generic
+       * "Continue working…" nudge (which, being verbatim-identical each turn, is
+       * itself part of the repetition attractor).
+       */
+      buildIntervention(obs) {
+        const pct2 = Math.round(obs.similarity * 100);
+        const quoted = obs.matchedPreview.replace(/\s+/g, " ").slice(0, 120);
+        if (obs.echoCount <= 1) {
+          return `[ECHO BREAK] Your last message is ${pct2}% identical to a previous message of yours ("${quoted}…") and neither included a tool call. The plan is already recorded — writing it again does nothing. Your next output MUST be a tool call executing the FIRST concrete step of that plan (e.g. file_write, shell, list_directory). Do not produce any text-only response.`;
+        }
+        if (obs.echoCount === 2) {
+          return `[ECHO BREAK — SECOND WARNING] You have now restated the same plan ${obs.echoCount + 1} times with zero tool calls. Text-only planning is FORBIDDEN for the rest of this task. Choose exactly one:
+  1. Call a tool that mutates or inspects the workspace (file_write / shell / file_read).
+  2. If genuinely blocked, call task_complete with a summary that names the exact blocker.
+Any further text-only response will be discarded.`;
+        }
+        return `[ECHO BREAK — FINAL] ${obs.echoCount + 1} near-identical text-only responses detected. This trajectory is dead. Abandon the current phrasing entirely: do not describe, do not plan. Emit ONLY a tool call. If no tool call is possible, call task_complete and report the blocker.`;
+      }
+      /** Test/telemetry helper. */
+      snapshot() {
+        return { streak: this.streak, windowSize: this.recent.length };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/permissionRuleset.js
 function checkDoomLoop(context2) {
   const history = context2.toolCallHistory;
@@ -567254,7 +567474,109 @@ function reconcileCompletedTodosWithEvidence(input) {
     downgrades
   };
 }
-var NON_WORK_TOOLS, VISUAL_EVIDENCE_TOOLS, AUDIO_EVIDENCE_TOOLS;
+function extractPathTokens(content) {
+  const withSeparator = [];
+  const bareFilenames = [];
+  const stripped = content.replace(/https?:\/\/\S+/g, " ").replace(/`/g, " ");
+  for (const raw of stripped.match(PATH_TOKEN_RE) ?? []) {
+    const hadSeparator = raw.includes("/");
+    const token = raw.replace(/[.,;:!?)]+$/, "").replace(/\/+$/, "");
+    if (!token || token.length < 3)
+      continue;
+    if (/^v?\d+(\.\d+)*$/i.test(token))
+      continue;
+    if (NON_FILE_SUFFIXES.has(token.toLowerCase()))
+      continue;
+    if (hadSeparator)
+      withSeparator.push(token);
+    else
+      bareFilenames.push(token);
+  }
+  return { withSeparator, bareFilenames };
+}
+function looksLikeDirectory(pathToken) {
+  const last2 = pathToken.split("/").pop() ?? "";
+  return !last2.includes(".");
+}
+function reconcileRestoredTodosWithDisk(input) {
+  const cleaned = [];
+  let droppedCorrupt = 0;
+  for (const todo of input.todos) {
+    const valid = todo && typeof todo.content === "string" && todo.content.trim().length > 0 && typeof todo.status === "string" && ["pending", "in_progress", "completed", "blocked"].includes(todo.status);
+    if (valid)
+      cleaned.push({ ...todo });
+    else
+      droppedCorrupt++;
+  }
+  const index = buildTodoTruthIndex(cleaned);
+  const downgrades = [];
+  const contextDirsFor = (todo) => {
+    const dirs = [];
+    let cur = todo;
+    const seen = /* @__PURE__ */ new Set();
+    while (cur) {
+      if (cur.id && seen.has(cur.id))
+        break;
+      if (cur.id)
+        seen.add(cur.id);
+      const { withSeparator } = extractPathTokens(cur.content);
+      for (const p2 of withSeparator) {
+        if (looksLikeDirectory(p2))
+          dirs.push(p2);
+      }
+      cur = cur.parentId ? index.byId.get(cur.parentId) : void 0;
+    }
+    return dirs;
+  };
+  for (const todo of cleaned) {
+    if (todo.status !== "completed")
+      continue;
+    const declared = (todo.declaredArtifacts ?? []).filter((a2) => typeof a2 === "string" && a2.trim().length > 0);
+    const { withSeparator, bareFilenames } = extractPathTokens(todo.content);
+    const contextDirs = contextDirsFor(todo);
+    const candidates = /* @__PURE__ */ new Set();
+    for (const a2 of declared)
+      candidates.add(input.resolvePath(input.workingDir, a2));
+    for (const p2 of withSeparator)
+      candidates.add(input.resolvePath(input.workingDir, p2));
+    for (const f2 of bareFilenames) {
+      candidates.add(input.resolvePath(input.workingDir, f2));
+      for (const dir of contextDirs) {
+        candidates.add(input.resolvePath(input.workingDir, dir, f2));
+      }
+    }
+    if (candidates.size === 0)
+      continue;
+    let anyExists = false;
+    for (const abs of candidates) {
+      if (input.exists(abs)) {
+        anyExists = true;
+        break;
+      }
+    }
+    if (anyExists)
+      continue;
+    const shown = [...candidates].slice(0, 4).join(", ");
+    const blocker = `Restored completion claim contradicts the local disk: none of the referenced artifacts exist (checked: ${shown}). The prior session's work is not present in this workspace. Do NOT search for these artifacts — CREATE them (file_write/shell mkdir) as the next step.`;
+    downgrades.push({
+      id: todo.id,
+      content: todo.content,
+      from: "completed",
+      to: "pending",
+      blocker,
+      evidence: `disk verification at restore: 0/${candidates.size} candidate path(s) exist`
+    });
+    todo.status = "pending";
+    todo.blocker = blocker;
+  }
+  return {
+    todos: cleaned,
+    changed: downgrades.length > 0 || droppedCorrupt > 0,
+    downgrades,
+    droppedCorrupt
+  };
+}
+var NON_WORK_TOOLS, VISUAL_EVIDENCE_TOOLS, AUDIO_EVIDENCE_TOOLS, PATH_TOKEN_RE, NON_FILE_SUFFIXES;
 var init_todoTruth = __esm({
   "packages/orchestrator/dist/todoTruth.js"() {
     "use strict";
@@ -567278,6 +567600,13 @@ var init_todoTruth = __esm({
       "transcribe_url",
       "video_understand"
     ]);
+    PATH_TOKEN_RE = /[A-Za-z0-9_.~-]*\/[A-Za-z0-9_.\/~-]*|[A-Za-z0-9_-]+\.[A-Za-z0-9]{1,8}\b/g;
+    NON_FILE_SUFFIXES = /* @__PURE__ */ new Set([
+      // common sentence-token false positives ("e.g.", version numbers, hosts)
+      "e.g",
+      "i.e",
+      "vs"
+    ]);
   }
 });
 
@@ -578759,6 +579088,175 @@ var init_evidenceLedger = __esm({
   }
 });
 
+// packages/orchestrator/dist/observationLedger.js
+function hashText(text2) {
+  let h = 2166136261;
+  for (let i2 = 0; i2 < text2.length; i2++) {
+    h ^= text2.charCodeAt(i2);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function boundOutput(output) {
+  if (output.length <= ENTRY_FULL_CHARS)
+    return output;
+  const head = output.slice(0, ENTRY_HEAD_CHARS);
+  const tail = output.slice(-ENTRY_TAIL_CHARS);
+  return `${head}
+  … (${output.length - ENTRY_HEAD_CHARS - ENTRY_TAIL_CHARS} chars elided — full output was in the turn it ran) …
+${tail}`;
+}
+function labelFor(tool, args) {
+  const a2 = args ?? {};
+  const pick = (...keys) => {
+    for (const k of keys) {
+      const v = a2[k];
+      if (typeof v === "string" && v.trim())
+        return v.trim();
+    }
+    return "";
+  };
+  let detail = "";
+  switch (tool) {
+    case "shell":
+    case "shell_async":
+      detail = pick("command", "cmd");
+      break;
+    case "web_fetch":
+      detail = pick("url", "target");
+      break;
+    case "web_search":
+      detail = pick("query", "q");
+      break;
+    case "list_directory":
+    case "file_explore":
+      detail = pick("path") || ".";
+      break;
+    case "grep_search":
+    case "find_files":
+      detail = [pick("pattern", "query"), pick("path")].filter(Boolean).join(" in ");
+      break;
+    default:
+      detail = pick("path", "url", "query", "command", "target");
+  }
+  const flat = detail.replace(/\s+/g, " ").slice(0, 120);
+  return flat ? `${tool}: ${flat}` : tool;
+}
+var SKIP_TOOLS, ENTRY_FULL_CHARS, ENTRY_HEAD_CHARS, ENTRY_TAIL_CHARS, MAX_ENTRIES2, ObservationLedger;
+var init_observationLedger = __esm({
+  "packages/orchestrator/dist/observationLedger.js"() {
+    "use strict";
+    SKIP_TOOLS = /* @__PURE__ */ new Set([
+      "file_read",
+      // EvidenceLedger's domain
+      "todo_write",
+      "todo_read",
+      "task_complete",
+      "memory_read",
+      "memory_write",
+      "working_notes"
+    ]);
+    ENTRY_FULL_CHARS = 1200;
+    ENTRY_HEAD_CHARS = 700;
+    ENTRY_TAIL_CHARS = 300;
+    MAX_ENTRIES2 = 24;
+    ObservationLedger = class {
+      entries = /* @__PURE__ */ new Map();
+      record(input) {
+        const { tool, fingerprint, output, success, turn } = input;
+        if (!fingerprint || SKIP_TOOLS.has(tool))
+          return;
+        const trimmed = (output ?? "").trim();
+        if (!trimmed)
+          return;
+        const outputHash = hashText(trimmed);
+        const existing = this.entries.get(fingerprint);
+        if (existing) {
+          const identical = existing.outputHash === outputHash;
+          this.entries.delete(fingerprint);
+          this.entries.set(fingerprint, {
+            ...existing,
+            output: boundOutput(trimmed),
+            fullChars: trimmed.length,
+            success,
+            lastTurn: turn,
+            runs: existing.runs + 1,
+            identicalRuns: identical ? existing.identicalRuns + 1 : 1,
+            outputHash
+          });
+          return;
+        }
+        this.entries.set(fingerprint, {
+          fingerprint,
+          tool,
+          label: labelFor(tool, input.args),
+          output: boundOutput(trimmed),
+          fullChars: trimmed.length,
+          success,
+          lastTurn: turn,
+          runs: 1,
+          identicalRuns: 1,
+          outputHash
+        });
+        while (this.entries.size > MAX_ENTRIES2) {
+          const oldest = this.entries.keys().next().value;
+          if (oldest === void 0)
+            break;
+          this.entries.delete(oldest);
+        }
+      }
+      /** Consecutive identical-output executions for a fingerprint (0 if unseen). */
+      identicalRunsFor(fingerprint) {
+        return this.entries.get(fingerprint)?.identicalRuns ?? 0;
+      }
+      size() {
+        return this.entries.size;
+      }
+      clear() {
+        this.entries.clear();
+      }
+      /**
+       * Render the CURRENT OBSERVED STATE block for the frame. Newest first,
+       * bounded to maxChars. Every entry shows outcome, repeat counts, and the
+       * actual output — the ground truth the model must reason from.
+       */
+      renderBlock(maxChars = 5e3) {
+        if (this.entries.size === 0)
+          return null;
+        const newestFirst = [...this.entries.values()].reverse();
+        const lines = [
+          "[CURRENT OBSERVED STATE — latest output of each distinct tool call this run]",
+          "This is the ground truth your tools actually returned (regenerated every turn; survives compaction).",
+          "Reason from these outputs — NOT from your earlier prose about them. If an entry says the output was identical across repeats, re-running that exact call will return the same thing again.",
+          ""
+        ];
+        let used = lines.join("\n").length;
+        for (const e2 of newestFirst) {
+          const outcome = e2.success ? "ok" : "FAILED";
+          const repeat = e2.runs > 1 ? e2.identicalRuns >= 2 ? ` (run ${e2.runs}×; output IDENTICAL ${e2.identicalRuns}× in a row — no new information)` : ` (run ${e2.runs}×; output changed on the last run)` : "";
+          const header = `▸ [${outcome}] ${e2.label} — turn ${e2.lastTurn}${repeat}`;
+          const body = e2.output.split("\n").map((l2) => `    ${l2}`).join("\n");
+          const chunk = `${header}
+${body}
+`;
+          if (used + chunk.length > maxChars) {
+            const stub = `▸ [${outcome}] ${e2.label} — turn ${e2.lastTurn}${repeat} (output elided for budget)
+`;
+            if (used + stub.length <= maxChars) {
+              lines.push(stub);
+              used += stub.length;
+            }
+            continue;
+          }
+          lines.push(chunk);
+          used += chunk.length;
+        }
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/contextWindowDump.js
 import { existsSync as existsSync102, mkdirSync as mkdirSync58, readdirSync as readdirSync32, readFileSync as readFileSync78, statSync as statSync39, unlinkSync as unlinkSync17, writeFileSync as writeFileSync48, appendFileSync as appendFileSync9 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
@@ -581254,7 +581752,7 @@ var init_focusSupervisor = __esm({
 });
 
 // packages/orchestrator/dist/convergence-breaker.js
-var InMemoryConvergenceStore, DEFAULTS, ConvergenceBreaker;
+var InMemoryConvergenceStore, DEFAULTS2, ConvergenceBreaker;
 var init_convergence_breaker = __esm({
   "packages/orchestrator/dist/convergence-breaker.js"() {
     "use strict";
@@ -581271,7 +581769,7 @@ var init_convergence_breaker = __esm({
         return [...this.map.values()];
       }
     };
-    DEFAULTS = { warnRound: 2, stallRound: 3, abandonRound: 5 };
+    DEFAULTS2 = { warnRound: 2, stallRound: 3, abandonRound: 5 };
     ConvergenceBreaker = class {
       warnRound;
       stallRound;
@@ -581290,9 +581788,9 @@ var init_convergence_breaker = __esm({
       /** Last verification signal (error count) seen per family, for delta-based progress. */
       lastSignal = /* @__PURE__ */ new Map();
       constructor(options2 = {}) {
-        this.warnRound = Math.max(1, options2.warnRound ?? DEFAULTS.warnRound);
-        this.stallRound = Math.max(this.warnRound + 1, options2.stallRound ?? DEFAULTS.stallRound);
-        this.abandonRound = Math.max(this.stallRound + 1, options2.abandonRound ?? DEFAULTS.abandonRound);
+        this.warnRound = Math.max(1, options2.warnRound ?? DEFAULTS2.warnRound);
+        this.stallRound = Math.max(this.warnRound + 1, options2.stallRound ?? DEFAULTS2.stallRound);
+        this.abandonRound = Math.max(this.stallRound + 1, options2.abandonRound ?? DEFAULTS2.abandonRound);
         this.store = options2.store ?? new InMemoryConvergenceStore();
       }
       /**
@@ -586048,7 +586546,7 @@ function formatStagnantLine(c9, critical) {
   const tag = critical ? "STAGNANT-CRIT" : "STAGNANT";
   return `${tag}: ${shortFile(c9.key.file)} ${c9.count}${codeLabel} unchanged across ${c9.attemptsSinceCountChange} attempts — per-line edits aren't converging; consider reverting the affected region or rewriting it as a unit`;
 }
-var ERROR_PATTERNS, DEFAULTS2, ErrorClusterTracker;
+var ERROR_PATTERNS, DEFAULTS3, ErrorClusterTracker;
 var init_errorClusterTracker = __esm({
   "packages/orchestrator/dist/errorClusterTracker.js"() {
     "use strict";
@@ -586161,7 +586659,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
         }
       }
     ];
-    DEFAULTS2 = {
+    DEFAULTS3 = {
       warnAttempts: 3,
       criticalAttempts: 5,
       cooldownAttempts: 2,
@@ -586175,7 +586673,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
       // key → observations counter at last emit
       observationCounter = 0;
       constructor(options2 = {}) {
-        this.opts = { ...DEFAULTS2, ...options2 };
+        this.opts = { ...DEFAULTS3, ...options2 };
         this.now = options2.now ?? Date.now;
       }
       /**
@@ -587104,6 +587602,7 @@ var init_agenticRunner = __esm({
     "use strict";
     init_contextBudget();
     init_textSanitize();
+    init_text_echo_guard();
     init_permissionRuleset();
     init_steeringIntake();
     init_completionLedger();
@@ -587157,6 +587656,7 @@ var init_agenticRunner = __esm({
     init_context_fabric();
     init_context_compiler();
     init_evidenceLedger();
+    init_observationLedger();
     init_trajectory_checkpoint();
     init_adversaryStream();
     init_contextWindowDump();
@@ -587480,6 +587980,23 @@ var init_agenticRunner = __esm({
       // Loop Intervention escalation path. Reset when repetition score
       // drops below the recovery threshold (0.2).
       _smaFiredThisLoop = false;
+      // ROOT CAUSE FIX: one-shot system note describing restored-todo claims that
+      // were contradicted by the disk at session start. Injected into the initial
+      // context so the model starts from a truthful world model instead of
+      // discovering the contradiction through failed discovery loops.
+      _restoredTodoVerificationNote = null;
+      // ECHO-1: assistant text-echo guard (mode-collapse breaker). Every other
+      // loop defense keys off the tool-call log; this one detects the tool-free
+      // failure mode where the model restates the same text-only plan turn after
+      // turn (personaplex post-mortem: consecutive assistant messages at
+      // 0.77–1.00 similarity, zero tool calls). Detects echoes, collapses the
+      // earlier duplicates out of the live context (removing the attractor), and
+      // requests a one-shot sampling perturbation for the next completion.
+      _textEchoGuard = new TextEchoGuard();
+      // Turns remaining with a temperature floor applied to knock a greedy
+      // decoder off a repetition attractor. Set on echo detection; decremented
+      // when a request is built.
+      _echoTempBoostTurns = 0;
       // REG-50: same-file write-thrash detector cooldown. Once fired, give
       // the agent 8 turns to break out before re-firing. Distinct from REG-44
       // because the failure shape is different (writes >> reads, but stuck
@@ -587729,6 +588246,11 @@ var init_agenticRunner = __esm({
       // sees the evidence it already has instead of re-deriving it. See
       // evidenceLedger.ts.
       _evidenceLedger = new EvidenceLedger();
+      // OBS-1: durable "current observed state" for non-file_read tool outputs
+      // (shell/web_fetch/list_directory/…). EvidenceLedger's counterpart for the
+      // observation channels that were previously invisible after compaction —
+      // the model must see the raw outputs it is reasoning about, every turn.
+      _observationLedger = new ObservationLedger();
       // Generative, inference-driven adversary running as an async memory stream
       // adjacent to the main loop. Initialized per run when the step critic is
       // enabled and a backend is available. See adversaryStream.ts.
@@ -594276,6 +594798,7 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
         ].filter((block) => Boolean(block)));
         const trajectoryBlock = this.options.trajectoryCheckpoint === "shadow" ? null : trajectoryCheckpoint ? renderTrajectoryCheckpoint(trajectoryCheckpoint) : null;
         const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
+        const observationBlock = process.env["OMNIUS_DISABLE_OBSERVATION_FRAME"] === "1" ? null : this._observationLedger.renderBlock(5e3);
         const anchorsBlock = this.surfaceAnchors(messages2);
         const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
 ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
@@ -594400,6 +594923,19 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
+          // OBS-1: current observed state — the actual latest OUTPUT of each
+          // distinct non-file_read tool call. Higher priority than the names-only
+          // tool cache: the substance of what tools returned is more decision-
+          // relevant than the list of what ran. Survives compaction because it is
+          // regenerated from the ledger every turn.
+          signalFromBlock("tool_cache", "turn.observed-state", observationBlock, {
+            id: "observed-state",
+            dedupeKey: "turn.observed-state",
+            semanticKey: "context.observed-state",
+            priority: 94,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
           signalFromBlock("memory", "turn.ppr-memory", pprMemoryBlock, {
             id: "ppr-memory",
             dedupeKey: "turn.ppr-memory",
@@ -596448,6 +596984,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._lastSurfacedAnchorIds.clear();
         this._contextLedger = new ContextLedger();
         this._evidenceLedger = new EvidenceLedger();
+        this._observationLedger = new ObservationLedger();
         this._lastContextFrameDiagnostics = null;
         this._lastContextPressureSnapshot = null;
         this._lastFocusContextSnapshot = null;
@@ -596613,6 +597150,45 @@ Respond with the assessment and take the selected evidence-backed action.`;
           verbose: false
         });
         await this._initializeGitProgressBaseline();
+        this._restoredTodoVerificationNote = null;
+        try {
+          const restored = process.env["OMNIUS_DISABLE_RESTORED_TODO_VERIFY"] === "1" ? null : this.readSessionTodos();
+          if (restored && restored.length > 0) {
+            const verification = reconcileRestoredTodosWithDisk({
+              todos: restored,
+              workingDir: this.authoritativeWorkingDirectory(),
+              exists: (p2) => _fsExistsSync(p2),
+              resolvePath: (...segments) => _pathResolve(...segments)
+            });
+            if (verification.changed) {
+              writeTodos(this._sessionId, verification.todos.map((t2) => ({
+                id: t2.id,
+                content: t2.content,
+                status: t2.status,
+                parentId: t2.parentId,
+                blocker: t2.blocker,
+                verifyCommand: t2.verifyCommand,
+                declaredArtifacts: t2.declaredArtifacts
+              })));
+              const lines = verification.downgrades.slice(0, 6).map((d2) => `- "${d2.content.slice(0, 90)}": ${d2.from} -> ${d2.to} (${d2.evidence})`);
+              if (verification.downgrades.length > 0) {
+                this._restoredTodoVerificationNote = [
+                  `[RESTORED TODO VERIFICATION]`,
+                  `This session restored a todo list from a prior run. ${verification.downgrades.length} completed claim(s) were contradicted by the local disk and downgraded:`,
+                  ...lines,
+                  ``,
+                  `The referenced artifacts do NOT exist in this workspace. Do not search for them — the correct next action is to CREATE them (file_write / shell mkdir) or re-plan from the actual disk state.`
+                ].join("\n");
+              }
+              this.emit({
+                type: "status",
+                content: `Restored-todo disk verification: ${verification.downgrades.length} claim(s) downgraded, ${verification.droppedCorrupt} corrupt entr${verification.droppedCorrupt === 1 ? "y" : "ies"} dropped`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
+        } catch {
+        }
         this._emitModelResolutionTelemetry("main");
         void this._hookManager.runSessionHook("session_start", this._sessionId).catch(() => {
         });
@@ -596848,6 +597424,12 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
+        if (this._restoredTodoVerificationNote) {
+          messages2.splice(messages2.length - 1, 0, {
+            role: "system",
+            content: this._restoredTodoVerificationNote
+          });
+        }
         this._phaseMessageStartIdx = messages2.length;
         if (process.env["OMNIUS_DISABLE_DECOMP1"] !== "1") {
           try {
@@ -597500,6 +598082,16 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             });
           }
         }
+        if (process.env["OMNIUS_DISABLE_TEXT_ECHO_GUARD"] !== "1") {
+          const restoredCollapsed = this._textEchoGuard.collapseEchoes(messages2);
+          if (restoredCollapsed > 0) {
+            this.emit({
+              type: "status",
+              content: `ECHO-1: collapsed ${restoredCollapsed} near-duplicate assistant plan(s) from restored transcript before first turn`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
         for (let turn = 0; turn < turnCap; turn++) {
           clearTurnState(this._appState);
           this._maybeApplyThinkGuard();
@@ -599070,10 +599662,13 @@ ${memoryLines.join("\n")}`
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           this.gcSystemMessages(requestMessages);
           requestMessages = this._prepareModelFacingMessages(requestMessages, turn);
+          const echoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
+          if (this._echoTempBoostTurns > 0)
+            this._echoTempBoostTurns--;
           const chatRequest = {
             messages: requestMessages,
             tools: toolDefs,
-            temperature: this.options.temperature,
+            temperature: echoBoostedTemp,
             maxTokens: effectiveMaxTokens,
             timeoutMs: boundedRequestTimeoutMs()
           };
@@ -599479,6 +600074,7 @@ ${memoryLines.join("\n")}`
           if (msg.toolCalls && msg.toolCalls.length > 0) {
             consecutiveTextOnly = 0;
             consecutiveThinkOnly = 0;
+            this._textEchoGuard.noteToolProgress();
             msg.toolCalls = this._dedupeToolCallsForResponse(msg.toolCalls, turn);
             if (msg.toolCalls.length === 0) {
               messages2.push({
@@ -602959,6 +603555,30 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
               });
               break;
             }
+            if (process.env["OMNIUS_DISABLE_TEXT_ECHO_GUARD"] !== "1") {
+              const echoObs = this._textEchoGuard.observe(content);
+              if (echoObs.isEcho) {
+                const collapsedCount = this._textEchoGuard.collapseEchoes(messages2);
+                this._echoTempBoostTurns = 2;
+                this.emit({
+                  type: "status",
+                  content: `ECHO-1: text-only echo #${echoObs.echoCount} (${Math.round(echoObs.similarity * 100)}% similar to earlier message) — collapsed ${collapsedCount} duplicate(s), injecting pattern breaker`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                messages2.push({
+                  role: "system",
+                  content: this._textEchoGuard.buildIntervention(echoObs)
+                });
+                if (adversaryAddedGuidance) {
+                  this.drainPendingRuntimeGuidance(turn);
+                  while (this.pendingUserMessages.length > 0) {
+                    const userMsg = this.pendingUserMessages.shift();
+                    await this.appendInjectedUserMessage(userMsg, messages2, turn);
+                  }
+                }
+                continue;
+              }
+            }
             const codeBlockMatch = content.match(/```(?:bash|sh|shell|zsh)\s*\n([\s\S]*?)```/);
             const codeBlockLines = codeBlockMatch?.[1] ? codeBlockMatch[1].trim().split("\n").filter((l2) => l2.trim() && !l2.trim().startsWith("#")) : [];
             const everyLineLooksExecutable = codeBlockLines.length > 0 && codeBlockLines.every((l2) => {
@@ -603243,10 +603863,13 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
             this.gcSystemMessages(compactedMsgs);
             const modelFacingMessages = this._prepareModelFacingMessages(compactedMsgs, turn);
+            const bfEchoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
+            if (this._echoTempBoostTurns > 0)
+              this._echoTempBoostTurns--;
             const chatRequest = {
               messages: modelFacingMessages,
               tools: toolDefs,
-              temperature: this.options.temperature,
+              temperature: bfEchoBoostedTemp,
               maxTokens: this.options.maxTokens,
               timeoutMs: boundedRequestTimeoutMs(),
               numCtx: this.options.contextWindowSize || void 0
@@ -603371,6 +603994,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             if (msg.toolCalls && msg.toolCalls.length > 0) {
               consecutiveTextOnly = 0;
               consecutiveThinkOnly = 0;
+              this._textEchoGuard.noteToolProgress();
               msg.toolCalls = this._dedupeRepeatedToolCallIdsForResponse(msg.toolCalls, turn);
               if (msg.toolCalls.length === 0) {
                 messages2.push({
@@ -603547,6 +604171,23 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 });
                 break;
               }
+              if (process.env["OMNIUS_DISABLE_TEXT_ECHO_GUARD"] !== "1") {
+                const echoObsBF = this._textEchoGuard.observe(content);
+                if (echoObsBF.isEcho) {
+                  const collapsedBF = this._textEchoGuard.collapseEchoes(messages2);
+                  this._echoTempBoostTurns = 2;
+                  this.emit({
+                    type: "status",
+                    content: `ECHO-1: text-only echo #${echoObsBF.echoCount} in bf-cycle ${bruteForceCycle} (${Math.round(echoObsBF.similarity * 100)}% similar) — collapsed ${collapsedBF} duplicate(s), injecting pattern breaker`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  messages2.push({
+                    role: "system",
+                    content: this._textEchoGuard.buildIntervention(echoObsBF)
+                  });
+                  continue;
+                }
+              }
               messages2.push({
                 role: "system",
                 content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done."
@@ -604510,6 +605151,19 @@ ${marker}` : marker);
         return { role: "tool", content: messageContent, tool_call_id: toolCallId };
       }
       buildModelFacingToolMessage(output, toolCallId, toolName, args, success) {
+        if (process.env["OMNIUS_DISABLE_OBSERVATION_FRAME"] !== "1") {
+          try {
+            this._observationLedger.record({
+              tool: toolName,
+              args,
+              fingerprint: this._buildToolFingerprint(toolName, args ?? {}),
+              output,
+              success: success !== false,
+              turn: this._taskState?.toolCallCount ?? 0
+            });
+          } catch {
+          }
+        }
         return this.buildToolMessage(this.compactDiscoveryOutputForModel(toolName, args, output, success), toolCallId, toolName);
       }
       compactDiscoveryOutputForModel(toolName, args, output, success) {
@@ -612173,7 +612827,7 @@ function renderPlan(decisions, includeHeader) {
     footerBlock,
     renderedText,
     memoryPrefix,
-    prefixHash: hashText(memoryPrefix),
+    prefixHash: hashText2(memoryPrefix),
     tierDistribution,
     tokensEmitted,
     tokensBaselineNoWeighting,
@@ -612273,7 +612927,7 @@ function estimateTokens4(text2) {
     return 0;
   return Math.max(1, Math.ceil(text2.length / 4));
 }
-function hashText(text2) {
+function hashText2(text2) {
   return createHash35("sha256").update(text2).digest("hex");
 }
 var init_materialization_policy = __esm({
@@ -647365,7 +648019,7 @@ var init_status_bar = __esm({
           this.advanceStagePhase();
           this.renderFooterPreserveCursor();
           refreshTuiTasksAnimationFrame();
-          if ((this._trajectoryLiveBlockAppended || this._subAgentLiveBlockAppended) && this._activeViewId === "main" && this.stageBorderActive()) {
+          if ((this._trajectoryLiveBlockAppended || this._subAgentLiveBlockAppended) && this._activeViewId === "main" && supportsTruecolor() && (this.stageBorderActive() || this.hasRunningChildAgentView())) {
             this.refreshDynamicBlocks();
           }
           if (this._agentViews.size > 1 && (String(this.currentHeaderPanel).startsWith("sys-") || this._headerExpanded)) {
@@ -647382,6 +648036,15 @@ var init_status_bar = __esm({
       advanceStagePhase() {
         this._stagePhase = (this._stagePhase + 6) % 360;
       }
+      /** True while any non-main agent view (sub / full / telegram) is running.
+       *  Child-agent work does not sweep the MAIN stage, so the live-block
+       *  animation gate needs this signal in addition to stageBorderActive(). */
+      hasRunningChildAgentView() {
+        for (const view of this._agentViews.values()) {
+          if (view.id !== "main" && view.status === "running") return true;
+        }
+        return false;
+      }
       /**
        * Ensure the monitoring timer is running when the registry has entries
        * and the braille spinner is not active. Refreshes the buffer line
@@ -717693,13 +718356,13 @@ function isLikelyAgentSpeechEcho({
   if (!agentTokens.length) return { likelyEcho: false, echoSimilarity: 0, reason: "no_agent_speech" };
   const agentComparable = agentTokens.join(" ");
   const heardComparable = heardTokens.join(" ");
-  const echoSimilarity = jaccardSimilarity(heardTokens, agentTokens);
+  const echoSimilarity2 = jaccardSimilarity(heardTokens, agentTokens);
   const exactEcho = Boolean(heardComparable && agentComparable && (agentComparable.includes(heardComparable) || heardComparable.includes(agentComparable)));
   const orderedEcho = heardTokens.length >= 3 && isMostlyContainedInOrder(heardTokens, agentTokens);
-  const likelyEcho = echoSimilarity >= AGENT_ECHO_SIMILARITY || exactEcho || orderedEcho;
+  const likelyEcho = echoSimilarity2 >= AGENT_ECHO_SIMILARITY || exactEcho || orderedEcho;
   return {
     likelyEcho,
-    echoSimilarity,
+    echoSimilarity: echoSimilarity2,
     reason: likelyEcho ? "speaker_echo" : "pass"
   };
 }

package/npm-shrinkwrap.json

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

package/package.json

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