omnius 1.0.545 → 1.0.547

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;
@@ -6498,11 +6559,29 @@ import { resolve as resolve4 } from "node:path";
 function computeMaxUngatedLines(contextWindow) {
   if (contextWindow <= 0)
     return 200;
-  const budget = Math.floor(contextWindow * 0.15);
+  const budget = Math.floor(contextWindow * 0.2);
   const maxLines = Math.floor(budget / 10);
   return Math.max(80, Math.min(500, maxLines));
 }
-function buildStructuralPreview(lines, filePath, maxLines) {
+function exceedsInlineCharacterBudget(lines, contextWindow) {
+  const sourceBytes = Buffer.byteLength(lines.join("\n"), "utf8");
+  const projectedTokens = Math.ceil((sourceBytes + lines.length * 10 + 512) / 4);
+  const tokenBudget = contextWindow > 0 ? Math.floor(contextWindow * 0.2) : 2e3;
+  return projectedTokens > tokenBudget;
+}
+function boundedBranchPreview(prefix, preview, contextWindow) {
+  const tokenBudget = contextWindow > 0 ? Math.floor(contextWindow * 0.2) : 2e3;
+  const maxChars = Math.max(192, Math.max(0, tokenBudget - 128) * 4);
+  const combined = `${prefix}
+${preview}`;
+  if (combined.length <= maxChars)
+    return combined;
+  const suffix = "\n[preview truncated to the 20% context budget; use AgenticRunner branch extraction]";
+  if (suffix.length >= maxChars)
+    return suffix.slice(0, maxChars);
+  return `${combined.slice(0, maxChars - suffix.length).trimEnd()}${suffix}`;
+}
+function buildStructuralPreview(lines, filePath, maxLines, lineOffset = 0) {
   const total = lines.length;
   const HEAD = Math.min(30, Math.floor(maxLines * 0.35));
   const TAIL = Math.min(15, Math.floor(maxLines * 0.15));
@@ -6511,13 +6590,14 @@ function buildStructuralPreview(lines, filePath, maxLines) {
 `);
   parts.push(`## Lines 1-${HEAD}:`);
   for (let i2 = 0; i2 < HEAD; i2++) {
-    parts.push(`${String(i2 + 1).padStart(6)} | ${lines[i2]}`);
+    const line = lines[i2] ?? "";
+    parts.push(`${String(lineOffset + i2 + 1).padStart(6)} | ${line.slice(0, 400)}${line.length > 400 ? "…" : ""}`);
   }
   const sigs = [];
   for (let i2 = HEAD; i2 < total - TAIL; i2++) {
     const line = lines[i2];
     if (SIG_PATTERNS.some((p2) => p2.test(line))) {
-      sigs.push(`${String(i2 + 1).padStart(6)} | ${line}`);
+      sigs.push(`${String(lineOffset + i2 + 1).padStart(6)} | ${line.slice(0, 400)}${line.length > 400 ? "…" : ""}`);
     }
   }
   if (sigs.length > 0) {
@@ -6539,7 +6619,8 @@ function buildStructuralPreview(lines, filePath, maxLines) {
     parts.push(`
 ## Lines ${tailStart + 1}-${total}:`);
     for (let i2 = tailStart; i2 < total; i2++) {
-      parts.push(`${String(i2 + 1).padStart(6)} | ${lines[i2]}`);
+      const line = lines[i2] ?? "";
+      parts.push(`${String(lineOffset + i2 + 1).padStart(6)} | ${line.slice(0, 400)}${line.length > 400 ? "…" : ""}`);
     }
   }
   parts.push(``);
@@ -6595,7 +6676,7 @@ var init_file_read = __esm({
     FileReadTool = class {
       name = "file_read";
       aliases = ["read_file", "read", "cat"];
-      description = "Read the contents of a file. For large files (200+ lines), returns a structural preview with signatures — use offset/limit to read specific sections.";
+      description = "Read file contents. Payloads projected above 20% of context are branch-extracted by the agent runner; direct use returns a bounded structural preview. offset/limit does not bypass the budget.";
       parameters = {
         type: "object",
         properties: {
@@ -6640,7 +6721,21 @@ var init_file_read = __esm({
           const totalLines = lines.length;
           if (offset !== void 0 || limit !== void 0) {
             const startIdx = Math.max(0, (offset ?? 1) - 1);
-            lines = lines.slice(startIdx, limit ? startIdx + limit : void 0);
+            lines = lines.slice(startIdx, limit !== void 0 ? startIdx + Math.max(0, limit) : void 0);
+            if (exceedsInlineCharacterBudget(lines, this._contextWindowSize)) {
+              const maxLines2 = computeMaxUngatedLines(this._contextWindowSize);
+              return {
+                success: true,
+                output: boundedBranchPreview([
+                  fileContextHeader(filePath, content, { offset, limit }),
+                  `[BRANCH_REQUIRED] The selected range exceeds 20% of the context window and was not inlined. An AgenticRunner must route this request through branch extraction; direct callers receive only this bounded structural preview.`
+                ].join("\n"), buildStructuralPreview(lines, filePath, maxLines2, startIdx), this._contextWindowSize),
+                durationMs: performance.now() - start2,
+                mutated: false,
+                mutatedFiles: [],
+                beforeHash: contentHash(content)
+              };
+            }
             const numbered2 = lines.map((line, i2) => `${String(startIdx + i2 + 1).padStart(6)} | ${line}`).join("\n");
             const hash = contentHash(content);
             return {
@@ -6655,12 +6750,14 @@ ${numbered2}`,
           }
           touchFile(this.workingDir, filePath);
           const maxLines = computeMaxUngatedLines(this._contextWindowSize);
-          if (totalLines > maxLines) {
+          if (exceedsInlineCharacterBudget(lines, this._contextWindowSize)) {
             const notes = getFileNotes(this.workingDir, filePath);
             return {
               success: true,
-              output: `${fileContextHeader(filePath, content)}
-${buildStructuralPreview(lines, filePath, maxLines)}${notes ? "\n\n" + notes : ""}`,
+              output: boundedBranchPreview([
+                fileContextHeader(filePath, content),
+                `[BRANCH_REQUIRED] This file exceeds 20% of the context window and was not inlined. An AgenticRunner must route it through branch extraction.`
+              ].join("\n"), `${buildStructuralPreview(lines, filePath, maxLines)}${notes ? "\n\n" + notes : ""}`, this._contextWindowSize),
               durationMs: performance.now() - start2,
               mutated: false,
               mutatedFiles: [],
@@ -119389,7 +119486,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash53 } = __require("crypto");
+    var { createHash: createHash54 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -119700,14 +119797,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash53("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash54("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash53("sha256").update(result).digest("base64url");
+          return createHash54("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -124334,9 +124431,9 @@ var require_sha256 = __commonJS({
     var forge = require_forge();
     require_md();
     require_util2();
-    var sha2565 = module.exports = forge.sha256 = forge.sha256 || {};
-    forge.md.sha256 = forge.md.algorithms.sha256 = sha2565;
-    sha2565.create = function() {
+    var sha2566 = module.exports = forge.sha256 = forge.sha256 || {};
+    forge.md.sha256 = forge.md.algorithms.sha256 = sha2566;
+    sha2566.create = function() {
       if (!_initialized) {
         _init();
       }
@@ -262387,7 +262484,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes31, createHash: createHash53 } = __require("crypto");
+    var { randomBytes: randomBytes31, createHash: createHash54 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -263047,7 +263144,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash53("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash54("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -263414,7 +263511,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash53 } = __require("crypto");
+    var { createHash: createHash54 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -263715,7 +263812,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash53("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash54("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -276522,13 +276619,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash53 } = await import("node:crypto");
+          const { createHash: createHash54 } = await import("node:crypto");
           const snapshotDir = join44(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir7(snapshotDir, { recursive: true });
           const version5 = this.selfState.version;
           const snapshotPath = join44(snapshotDir, `v${version5}.json`);
           await writeFile12(snapshotPath, snapshot, "utf8");
-          const hash = createHash53("sha256").update(snapshot).digest("hex");
+          const hash = createHash54("sha256").update(snapshot).digest("hex");
           await writeFile12(join44(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -276661,8 +276758,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash53 } = __require("node:crypto");
-        const machineId = createHash53("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash54 } = __require("node:crypto");
+        const machineId = createHash54("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -276744,9 +276841,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash53 } = await import("node:crypto");
+            const { createHash: createHash54 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash53("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash54("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join44(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -566130,6 +566227,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 +567510,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 +567636,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"
+    ]);
   }
 });
 
@@ -576742,6 +577107,7 @@ var init_streaming_executor = __esm({
       reset() {
         this.tools.clear();
         this.insertionOrder = [];
+        this.executeFn = null;
       }
       // ─────────────────────────────────────────────────────────
       // Internal — Hannover-aligned concurrency control
@@ -578614,9 +578980,11 @@ var init_evidenceLedger = __esm({
         if (!path16 || !content)
           return;
         const built = buildExtract(content);
+        if (input.fidelity)
+          built.fidelity = input.fidelity;
         const existing = this.entries.get(path16);
         if (existing && existing.readVersion === fileVersion && !existing.stale) {
-          const keepNew = built.text.length >= existing.content.length;
+          const keepNew = input.fidelity === "extract" || built.text.length >= existing.content.length;
           this.entries.set(path16, {
             ...existing,
             content: keepNew ? built.text : existing.content,
@@ -578759,6 +579127,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 +581791,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 +581808,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 +581827,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();
       }
       /**
@@ -583584,6 +584121,7 @@ var init_completion_resolution_verifier = __esm({
 });
 
 // packages/orchestrator/dist/evidenceBranch.js
+import { createHash as createHash33 } from "node:crypto";
 function buildBranchExtractionBrief(input) {
   const path16 = cleanBriefText(input.path, 320) || "the requested file";
   const intent = firstBriefText([
@@ -583593,37 +584131,75 @@ function buildBranchExtractionBrief(input) {
   ]);
   const openQuestion = cleanBriefText(input.trajectoryOpenQuestion, 280);
   const focus = openQuestion || intent;
+  const goalAnchor = cleanBriefText(input.goalAnchor || input.currentStep || input.trajectoryAssessment || intent, 320);
   const request = openQuestion ? `Determine the exact file-local facts in ${path16} that answer this unresolved agent question: ${openQuestion}` : intent ? `Identify the exact file-local facts in ${path16} that the active agent needs before it can ${asActionClause(intent)}.` : `Identify the exact declarations, behavior, and configuration in ${path16} needed to choose the next narrow action.`;
+  const rangeLabel2 = input.requestedRange ? `requested range offset=${input.requestedRange.offset ?? 1}, limit=${input.requestedRange.limit ?? "EOF"}` : "whole-file read";
+  const budgetLabel = input.projectedReadTokens && input.contextWindowTokens ? ` The projected payload is ~${Math.max(0, input.projectedReadTokens)} tokens of a ${Math.max(0, input.contextWindowTokens)}-token context.` : "";
   const triggerEvidence = uniqueBriefLines([
-    `The active action is a whole-file read of ${path16}; disk inspection found ${Math.max(0, input.lineCount)} lines / ${Math.max(0, input.byteCount)} bytes, so the parent context would otherwise receive only a preview.`,
+    `The active action is a ${rangeLabel2} of ${path16}; disk inspection found ${Math.max(0, input.lineCount)} lines selected / ${Math.max(0, input.byteCount)} bytes selected.${budgetLabel}`,
+    input.routingReason ? `Branch routing reason: ${cleanBriefText(input.routingReason, 300)}` : "",
     input.trajectoryAssessment ? `Current trajectory assessment: ${cleanBriefText(input.trajectoryAssessment, 360)}` : "No current file-level evidence has been returned to the parent yet.",
     input.currentStep ? `Current task step: ${cleanBriefText(input.currentStep, 260)}` : "",
     input.recentFailure ? `Recent unresolved evidence: ${cleanBriefText(input.recentFailure, 320)}` : ""
   ]);
   const returnContract = focus ? `Return only the exact declarations, values, behavior, and line spans that resolve: ${focus}` : "Return only the exact declarations, values, behavior, and line spans needed for the next safe action.";
-  const retrievalQuery = uniqueBriefLines([
-    path16,
-    focus,
+  const requirementQuestions = uniqueBriefLines([
     openQuestion,
-    "relevant declarations behavior configuration line spans"
+    intent,
+    input.currentStep && input.currentStep !== intent ? input.currentStep : "",
+    input.recentFailure ? `Which file-local declaration, value, or behavior explains this unresolved failure: ${cleanBriefText(input.recentFailure, 260)}` : ""
+  ]).slice(0, 3);
+  if (requirementQuestions.length === 0) {
+    requirementQuestions.push(`Which declarations, values, and behavior in this file are required for the next narrow action?`);
+  }
+  const requirements = requirementQuestions.map((question, index) => ({
+    id: `R${index + 1}`,
+    question,
+    required: index === 0 || requirementQuestions.length === 1,
+    expectedEvidence: "Exact source declarations, literal values, control/configuration behavior, and their line anchors.",
+    searchTerms: queryTerms(question).slice(0, 16)
+  }));
+  const retrievalQuery = uniqueBriefLines([
+    ...requirements.map((requirement) => requirement.question),
+    input.recentFailure
   ]).join(" ");
+  const discoveryContract = {
+    version: 1,
+    path: path16,
+    goalAnchor: goalAnchor || "Choose the next narrow evidence-backed action.",
+    query: cleanBriefText(retrievalQuery, 700),
+    requirements,
+    completionCriteria: [
+      "Every required requirement is either supported by an exact anchored segment or explicitly marked unresolved.",
+      "Every returned factual claim names its source line span; discontiguous evidence remains separate.",
+      "Stop when the contract is satisfied, no new query/range is available, or the bounded search budget is exhausted."
+    ],
+    budget: {
+      maxRounds: 3,
+      maxWindowsPerRound: 3,
+      maxTotalWindows: MAX_WINDOWS,
+      maxPresentedLines: MAX_SNIPPET_LINES,
+      maxInjectedChars: 2400
+    }
+  };
   return {
     request: cleanBriefText(request, 520),
-    triggerEvidence: triggerEvidence.slice(0, 4),
+    triggerEvidence: triggerEvidence.slice(0, 5),
     returnContract: cleanBriefText(returnContract, 520),
-    retrievalQuery: cleanBriefText(retrievalQuery, 700)
+    retrievalQuery: cleanBriefText(retrievalQuery, 700),
+    discoveryContract
   };
 }
-function buildStructuralPreview2(lines, path16, query) {
+function buildStructuralPreview2(lines, path16, query, sourceLineOffset = 0) {
   const n2 = lines.length;
   const clip3 = (l2) => l2.length > 180 ? l2.slice(0, 180) + "…" : l2;
-  const head = lines.slice(0, HEAD_LINES2).map((l2, i2) => `${i2 + 1}: ${clip3(l2)}`);
+  const head = lines.slice(0, HEAD_LINES2).map((l2, i2) => `${sourceLineOffset + i2 + 1}: ${clip3(l2)}`);
   const isStructural = (l2) => /^\s*(<[A-Za-z!]|#{1,6}\s|def |class |function |export |interface |type |async |public |private |\[[^\]]+\]|[A-Za-z_][\w.]*\s*=)/.test(l2) && l2.trim().length > 0 && l2.trim().length <= 180;
   const markers = [];
   for (let i2 = HEAD_LINES2; i2 < n2; i2++) {
     const l2 = lines[i2];
     if (isStructural(l2))
-      markers.push(`${i2 + 1}: ${clip3(l2.trim())}`);
+      markers.push(`${sourceLineOffset + i2 + 1}: ${clip3(l2.trim())}`);
   }
   const MAX_MARKERS = 30;
   const sampled = markers.length > MAX_MARKERS ? Array.from({ length: MAX_MARKERS }, (_, k) => markers[Math.floor(k * markers.length / MAX_MARKERS)]) : markers;
@@ -583709,7 +584285,9 @@ function selectWindows(lines, terms2) {
   return chosen.sort((a2, b) => a2.start - b.start).map((m2) => ({
     start: m2.start + 1,
     end: m2.end + 1,
-    text: lines.slice(m2.start, m2.end + 1).join("\n"),
+    // A one-line minified artifact can be hundreds of KB. The branch prompt
+    // is bounded independently of line count; exact source remains local.
+    text: lines.slice(m2.start, m2.end + 1).map((line) => line.length > 400 ? `${line.slice(0, 400)}…` : line).join("\n"),
     score: m2.score
   }));
 }
@@ -583724,6 +584302,8 @@ ${w.text}`).join("\n\n");
     ...brief.triggerEvidence.map((evidence) => `- ${evidence}`),
     `Return contract: ${brief.returnContract}`,
     `Retrieval focus: ${brief.retrievalQuery}`,
+    brief.discoveryContract ? `Discovery contract: ${JSON.stringify(brief.discoveryContract)}` : "",
+    `Search-loop contract: resolve required facts from the supplied windows; if unresolved, return NEW narrow search terms. Never request or summarize the whole file.`,
     ``,
     `File excerpts:`,
     blocks,
@@ -583733,8 +584313,10 @@ ${w.text}`).join("\n\n");
     ` "source_start":<1-based line where the answer is, or null>,`,
     ` "source_end":<1-based end line, or null>,`,
     ` "confidence":0.0-1.0,  // how sure the excerpts actually contain the answer`,
+    ` "satisfied_requirement_ids":["R1"],`,
+    ` "refined_search_terms":["new exact symbol or phrase"],`,
     ` "found":true|false}`
-  ].join("\n");
+  ].filter(Boolean).join("\n");
 }
 function parseExtraction(raw) {
   if (!raw)
@@ -583758,127 +584340,442 @@ function parseExtraction(raw) {
     sourceStart: num3(o2["source_start"]),
     sourceEnd: num3(o2["source_end"]),
     confidence: Math.min(1, Math.max(0, conf)),
-    found: o2["found"] !== false
+    found: o2["found"] !== false,
+    satisfiedRequirementIds: Array.isArray(o2["satisfied_requirement_ids"]) ? o2["satisfied_requirement_ids"].map((value2) => cleanBriefText(value2, 40)).filter(Boolean).slice(0, 8) : [],
+    refinedSearchTerms: Array.isArray(o2["refined_search_terms"]) ? o2["refined_search_terms"].map((value2) => cleanBriefText(value2, 80)).filter(Boolean).slice(0, 8) : []
   };
 }
+function sha2564(text2) {
+  return createHash33("sha256").update(text2).digest("hex");
+}
+function lineNumberedExcerpt(lines, startIndex, endIndex, sourceLineOffset, maxLineChars = 240) {
+  return lines.slice(startIndex, endIndex + 1).map((line, index) => {
+    const clipped = line.length > maxLineChars ? `${line.slice(0, maxLineChars)}…` : line;
+    return `${sourceLineOffset + startIndex + index + 1}: ${clipped}`;
+  }).join("\n");
+}
+function rangesOverlap(a2, b) {
+  return a2.startLine <= b.endLine + 1 && b.startLine <= a2.endLine + 1;
+}
+function makeSegment(input) {
+  const segmentHash = sha2564(input.excerpt);
+  return {
+    id: `E${input.index + 1}-${segmentHash.slice(0, 10)}`,
+    requirementIds: [...new Set(input.requirementIds)],
+    summary: cleanBriefText(input.summary, 280),
+    excerpt: input.excerpt,
+    confidence: Math.min(1, Math.max(0, input.confidence)),
+    anchor: {
+      path: input.path,
+      startLine: input.startLine,
+      endLine: input.endLine,
+      contentHash: input.contentHash,
+      segmentHash
+    }
+  };
+}
+function renderSegments(segments, maxChars) {
+  const blocks = [];
+  let used = 0;
+  for (const segment of segments) {
+    const block = [
+      `[${segment.id} ${segment.anchor.path}:L${segment.anchor.startLine}-L${segment.anchor.endLine} requirements=${segment.requirementIds.join(",") || "supporting"}]`,
+      segment.excerpt
+    ].join("\n");
+    if (used + block.length > maxChars && blocks.length > 0)
+      break;
+    const clipped = block.slice(0, Math.max(0, maxChars - used));
+    blocks.push(clipped);
+    used += clipped.length + 1;
+  }
+  return blocks.join("\n");
+}
+function legacyContiguousSpan(segments) {
+  if (segments.length === 0)
+    return { start: null, end: null };
+  const sorted = [...segments].sort((a2, b) => a2.anchor.startLine - b.anchor.startLine);
+  for (let index = 1; index < sorted.length; index++) {
+    if (sorted[index].anchor.startLine > sorted[index - 1].anchor.endLine + 1) {
+      return { start: null, end: null };
+    }
+  }
+  return {
+    start: sorted[0].anchor.startLine,
+    end: sorted.at(-1).anchor.endLine
+  };
+}
+function requirementSearchPasses(brief) {
+  const requirements = brief.discoveryContract?.requirements ?? [];
+  const passes = requirements.map((requirement) => ({
+    id: requirement.id,
+    query: requirement.question,
+    strategy: "literal"
+  }));
+  if (passes.length === 0 && brief.retrievalQuery) {
+    passes.push({ id: "R1", query: brief.retrievalQuery, strategy: "literal" });
+  }
+  return passes.slice(0, brief.discoveryContract?.budget.maxRounds ?? 3);
+}
+function deterministicSegments(input) {
+  const { lines, path: path16, contentHash: contentHash2, sourceLineOffset, brief } = input;
+  const segments = [];
+  const satisfied = /* @__PURE__ */ new Set();
+  const rounds = [];
+  const lowers = lines.map((line) => line.toLowerCase());
+  const lineCount = Math.max(1, lines.length);
+  const passes = requirementSearchPasses(brief);
+  let totalMatches = 0;
+  for (const pass of passes) {
+    const terms2 = queryTerms(pass.query);
+    const weights = /* @__PURE__ */ new Map();
+    for (const term of terms2) {
+      let documentFrequency = 0;
+      for (const line of lowers)
+        if (line.includes(term))
+          documentFrequency++;
+      weights.set(term, documentFrequency === 0 ? 0 : Math.log(lineCount / documentFrequency) + 0.1);
+    }
+    const hits = [];
+    for (let index = 0; index < lines.length; index++) {
+      const matched = terms2.filter((term) => lowers[index].includes(term));
+      const score = matched.reduce((sum2, term) => sum2 + (weights.get(term) ?? 0), 0);
+      if (score > 0)
+        hits.push({ index, score, matched });
+    }
+    totalMatches += hits.length;
+    const ranked = hits.sort((a2, b) => b.score - a2.score).slice(0, 4);
+    for (const hit of ranked) {
+      if (segments.length >= input.maxSegments)
+        break;
+      const startIndex = Math.max(0, hit.index - 2);
+      const endIndex = Math.min(lines.length - 1, hit.index + 2);
+      const absolute = {
+        startLine: sourceLineOffset + startIndex + 1,
+        endLine: sourceLineOffset + endIndex + 1
+      };
+      if (segments.some((segment) => rangesOverlap(segment.anchor, absolute))) {
+        continue;
+      }
+      const discriminatingTerms = terms2.filter((term) => (weights.get(term) ?? 0) > 0);
+      const coverage = discriminatingTerms.length > 0 ? hit.matched.length / discriminatingTerms.length : 0;
+      const confidence2 = Math.min(1, Math.max(0.2, coverage));
+      if (confidence2 < EXTRACT_CONFIDENCE_FLOOR)
+        continue;
+      const excerpt = lineNumberedExcerpt(lines, startIndex, endIndex, sourceLineOffset);
+      segments.push(makeSegment({
+        path: path16,
+        contentHash: contentHash2,
+        requirementIds: [pass.id],
+        summary: `Literal/identifier evidence for ${pass.query}`,
+        excerpt,
+        startLine: absolute.startLine,
+        endLine: absolute.endLine,
+        confidence: confidence2,
+        index: segments.length
+      }));
+      satisfied.add(pass.id);
+    }
+  }
+  rounds.push({
+    round: 1,
+    strategy: "literal",
+    query: cleanBriefText(passes.map((pass) => pass.query).join(" | "), 180),
+    matches: totalMatches
+  });
+  return { segments, satisfied: [...satisfied], rounds };
+}
 async function extractEvidence(opts) {
   const { path: path16, content, fileVersion, backend } = opts;
+  const sourceLineOffset = Math.max(0, Math.floor(opts.sourceLineOffset ?? 0));
   const brief = opts.brief ?? buildBranchExtractionBrief({
     path: path16,
     lineCount: content.split("\n").length,
-    byteCount: content.length,
+    byteCount: Buffer.byteLength(content, "utf8"),
     assistantIntent: opts.query
   });
   const query = brief.retrievalQuery || opts.query;
   const lines = content.split("\n");
-  const terms2 = queryTerms(query);
-  if (terms2.length > 0) {
-    const lowers = lines.map((l2) => l2.toLowerCase());
-    const N = Math.max(1, lines.length);
-    const weight = /* @__PURE__ */ new Map();
-    for (const t2 of terms2) {
-      let df = 0;
-      for (const l2 of lowers)
-        if (l2.includes(t2))
-          df++;
-      weight.set(t2, df === 0 ? 0 : Math.log(N / df) + 0.1);
+  const contentHash2 = opts.contentHash || sha2564(content);
+  const byteCount = Buffer.byteLength(content, "utf8");
+  const requirements = brief.discoveryContract?.requirements ?? [
+    {
+      id: "R1",
+      question: query,
+      required: true,
+      expectedEvidence: "Anchored source evidence",
+      searchTerms: queryTerms(query)
     }
-    const hits = [];
-    for (let i2 = 0; i2 < lines.length; i2++) {
-      const lower = lowers[i2];
-      let score = 0;
-      for (const t2 of terms2)
-        if (lower.includes(t2))
-          score += weight.get(t2) ?? 0;
-      if (score > 0)
-        hits.push({ idx: i2, score });
-    }
-    if (hits.length > 0) {
-      const CHAR_BUDGET = 900;
-      const ranked = [...hits].sort((a2, b) => b.score - a2.score).slice(0, 8);
-      const MAX_LINE = 200;
-      const snippets = ranked.map((h) => {
-        const lo = Math.max(0, h.idx - 2);
-        const hi = Math.min(lines.length - 1, h.idx + 2);
-        const text2 = lines.slice(lo, hi + 1).map((l2, k) => {
-          const v = l2.length > MAX_LINE ? l2.slice(0, MAX_LINE) + "…" : l2;
-          return `${lo + k + 1}: ${v}`;
-        }).join("\n");
-        return { score: h.score, start: lo + 1, end: hi + 1, text: text2 };
-      });
-      const kept = [];
-      let used = 0;
-      for (const s2 of snippets) {
-        if (used + s2.text.length + 1 > CHAR_BUDGET && kept.length > 0)
+  ];
+  const maxSegments = Math.max(1, Math.min(brief.discoveryContract?.budget.maxTotalWindows ?? MAX_WINDOWS, MAX_WINDOWS));
+  const maxInjectedChars = Math.max(600, Math.min(brief.discoveryContract?.budget.maxInjectedChars ?? 2400, 4e3));
+  const deterministic = deterministicSegments({
+    lines,
+    path: path16,
+    contentHash: contentHash2,
+    sourceLineOffset,
+    brief,
+    maxSegments
+  });
+  const requiredIds = requirements.filter((requirement) => requirement.required).map((requirement) => requirement.id);
+  const deterministicSatisfied = new Set(deterministic.satisfied);
+  if (deterministic.segments.length > 0 && requiredIds.every((id2) => deterministicSatisfied.has(id2))) {
+    const claim = renderSegments(deterministic.segments, maxInjectedChars);
+    const legacySpan = legacyContiguousSpan(deterministic.segments);
+    return {
+      path: path16,
+      query,
+      claim,
+      sourceStart: legacySpan.start,
+      sourceEnd: legacySpan.end,
+      fileVersion,
+      confidence: Math.max(...deterministic.segments.map((segment) => segment.confidence)),
+      exploredLines: lines.length,
+      injectedChars: claim.length,
+      segments: deterministic.segments,
+      satisfiedRequirementIds: [...deterministicSatisfied],
+      unresolvedRequirementIds: requirements.map((requirement) => requirement.id).filter((id2) => !deterministicSatisfied.has(id2)),
+      provenance: {
+        contentHash: contentHash2,
+        byteCount,
+        lineCount: lines.length,
+        fileVersion,
+        exploredRanges: deterministic.segments.map((segment) => ({
+          startLine: segment.anchor.startLine,
+          endLine: segment.anchor.endLine
+        })),
+        searchRounds: deterministic.rounds,
+        truncated: deterministic.segments.length >= maxSegments
+      }
+    };
+  }
+  const seenQueries = /* @__PURE__ */ new Set();
+  let activeQuery = query;
+  let parsed = null;
+  let parsedWindows = [];
+  const searchRounds = [...deterministic.rounds];
+  let remainingWindows = Math.min(MAX_WINDOWS, brief.discoveryContract?.budget.maxTotalWindows ?? MAX_WINDOWS);
+  let remainingPresentedLines = Math.min(MAX_SNIPPET_LINES, brief.discoveryContract?.budget.maxPresentedLines ?? MAX_SNIPPET_LINES);
+  if (backend) {
+    const maxSemanticRounds = Math.max(0, (brief.discoveryContract?.budget.maxRounds ?? 3) - searchRounds.length);
+    for (let attempt = 0; attempt < Math.min(2, maxSemanticRounds); attempt++) {
+      const queryKey = cleanBriefText(activeQuery, 700).toLowerCase();
+      if (!queryKey || seenQueries.has(queryKey))
+        break;
+      seenQueries.add(queryKey);
+      const activeTerms = queryTerms(activeQuery);
+      const perRound = Math.min(remainingWindows, brief.discoveryContract?.budget.maxWindowsPerRound ?? 3);
+      const selectedWindows = [];
+      for (const window2 of selectWindows(lines, activeTerms)) {
+        if (selectedWindows.length >= perRound)
+          break;
+        const windowLines = window2.end - window2.start + 1;
+        if (windowLines > remainingPresentedLines)
           continue;
-        kept.push(s2);
-        used += s2.text.length + 1;
-      }
-      kept.sort((a2, b) => a2.start - b.start);
-      const claim2 = kept.map((s2) => s2.text).join("\n  …\n");
-      const starts = kept.map((s2) => s2.start);
-      const ends = kept.map((s2) => s2.end);
-      const snippetLower = claim2.toLowerCase();
-      const covered = terms2.filter((t2) => snippetLower.includes(t2)).length;
-      const grepConfidence = Math.min(1, covered / Math.max(1, terms2.length));
-      if (grepConfidence >= EXTRACT_CONFIDENCE_FLOOR) {
-        return {
-          path: path16,
-          query,
-          claim: claim2,
-          sourceStart: starts.length ? Math.min(...starts) : null,
-          sourceEnd: ends.length ? Math.max(...ends) : null,
-          fileVersion,
-          confidence: grepConfidence,
-          exploredLines: lines.length,
-          injectedChars: claim2.length
-        };
+        selectedWindows.push(window2);
+        remainingPresentedLines -= windowLines;
+      }
+      remainingWindows -= selectedWindows.length;
+      const relativeWindows = selectedWindows.map((window2) => ({
+        start: window2.start + sourceLineOffset,
+        end: window2.end + sourceLineOffset,
+        text: window2.text
+      }));
+      if (relativeWindows.length === 0)
+        break;
+      parsedWindows = relativeWindows;
+      searchRounds.push({
+        round: searchRounds.length + 1,
+        strategy: attempt === 0 ? "semantic" : "refined",
+        query: cleanBriefText(activeQuery, 180),
+        matches: relativeWindows.length
+      });
+      try {
+        const resp = await backend.chatCompletion({
+          messages: [
+            {
+              role: "system",
+              content: "You extract precise facts from bounded file excerpts. Output ONLY a JSON object and never invent source text or line spans."
+            },
+            { role: "user", content: extractionPrompt(brief, path16, relativeWindows) }
+          ],
+          tools: [],
+          temperature: 0,
+          maxTokens: 900,
+          timeoutMs: opts.timeoutMs ?? 3e4
+        });
+        parsed = parseExtraction(resp.choices?.[0]?.message?.content ?? "");
+      } catch {
+        parsed = null;
       }
+      if (parsed?.found)
+        break;
+      const refined = uniqueBriefLines(parsed?.refinedSearchTerms ?? []).join(" ");
+      if (!refined || seenQueries.has(refined.toLowerCase()))
+        break;
+      activeQuery = refined;
     }
   }
-  const windows = lines.length <= WINDOW_LINES * 2 ? [{ start: 1, end: lines.length, text: content, score: 1 }] : selectWindows(lines, terms2);
-  const exploredLines = windows.reduce((n2, w) => n2 + (w.end - w.start + 1), 0);
-  let parsed = null;
-  for (let attempt = 0; attempt < 2 && !parsed; attempt++) {
-    try {
-      const resp = await backend.chatCompletion({
-        messages: [
-          { role: "system", content: "You extract precise facts from file excerpts. Output ONLY a JSON object." },
-          { role: "user", content: extractionPrompt(brief, path16, windows) }
-        ],
-        tools: [],
-        temperature: 0,
-        maxTokens: 900,
-        timeoutMs: opts.timeoutMs ?? 3e4
+  let semanticSegment = null;
+  if (parsed?.found && parsed.claim && Number.isInteger(parsed.sourceStart) && Number.isInteger(parsed.sourceEnd) && parsed.sourceStart <= parsed.sourceEnd && parsedWindows.some((window2) => parsed.sourceStart >= window2.start && parsed.sourceEnd <= window2.end)) {
+    const startIndex = parsed.sourceStart - sourceLineOffset - 1;
+    const endIndex = parsed.sourceEnd - sourceLineOffset - 1;
+    if (startIndex >= 0 && endIndex < lines.length) {
+      semanticSegment = makeSegment({
+        path: path16,
+        contentHash: contentHash2,
+        requirementIds: parsed.satisfiedRequirementIds.length > 0 ? parsed.satisfiedRequirementIds : [requirements[0].id],
+        summary: parsed.claim,
+        excerpt: lineNumberedExcerpt(lines, startIndex, endIndex, sourceLineOffset),
+        startLine: parsed.sourceStart,
+        endLine: parsed.sourceEnd,
+        confidence: parsed.confidence,
+        index: deterministic.segments.length
       });
-      parsed = parseExtraction(resp.choices?.[0]?.message?.content ?? "");
-    } catch {
-      parsed = null;
     }
   }
-  const claim = parsed && parsed.found && parsed.claim ? parsed.claim : buildStructuralPreview2(lines, path16, query);
+  const segments = [...deterministic.segments];
+  if (semanticSegment && !segments.some((segment) => rangesOverlap(segment.anchor, semanticSegment.anchor))) {
+    segments.push(semanticSegment);
+  }
+  const satisfied = new Set(deterministic.satisfied);
+  for (const segment of segments) {
+    for (const id2 of segment.requirementIds)
+      satisfied.add(id2);
+  }
+  if (segments.length > 0) {
+    const claim = renderSegments(segments, maxInjectedChars);
+    const legacySpan = legacyContiguousSpan(segments);
+    return {
+      path: path16,
+      query,
+      claim,
+      sourceStart: legacySpan.start,
+      sourceEnd: legacySpan.end,
+      fileVersion,
+      confidence: Math.max(...segments.map((segment) => segment.confidence)),
+      exploredLines: Math.min(lines.length, parsedWindows.reduce((sum2, window2) => sum2 + (window2.end - window2.start + 1), 0) || lines.length),
+      injectedChars: claim.length,
+      segments,
+      satisfiedRequirementIds: [...satisfied],
+      unresolvedRequirementIds: requirements.map((requirement) => requirement.id).filter((id2) => !satisfied.has(id2)),
+      provenance: {
+        contentHash: contentHash2,
+        byteCount,
+        lineCount: lines.length,
+        fileVersion,
+        exploredRanges: segments.map((segment) => ({
+          startLine: segment.anchor.startLine,
+          endLine: segment.anchor.endLine
+        })),
+        searchRounds,
+        truncated: segments.length >= maxSegments
+      }
+    };
+  }
+  const structuralClaim = buildStructuralPreview2(lines, path16, query, sourceLineOffset);
+  const headEndIndex = Math.max(0, Math.min(lines.length - 1, HEAD_LINES2 - 1));
+  const structuralSegment = makeSegment({
+    path: path16,
+    contentHash: contentHash2,
+    requirementIds: [],
+    summary: "Structural navigation anchor; required facts remain unresolved.",
+    excerpt: lineNumberedExcerpt(lines, 0, headEndIndex, sourceLineOffset),
+    startLine: sourceLineOffset + 1,
+    endLine: sourceLineOffset + headEndIndex + 1,
+    confidence: 0.2,
+    index: 0
+  });
+  const maxRounds = brief.discoveryContract?.budget.maxRounds ?? 3;
+  if (searchRounds.length < maxRounds) {
+    searchRounds.push({
+      round: searchRounds.length + 1,
+      strategy: "structural",
+      query: cleanBriefText(query, 180),
+      matches: 1
+    });
+  }
   return {
     path: path16,
     query,
-    claim,
-    sourceStart: parsed?.sourceStart ?? null,
-    sourceEnd: parsed?.sourceEnd ?? null,
+    claim: structuralClaim.slice(0, maxInjectedChars),
+    sourceStart: structuralSegment.anchor.startLine,
+    sourceEnd: structuralSegment.anchor.endLine,
     fileVersion,
-    confidence: parsed?.found ? parsed.confidence : 0.2,
-    exploredLines,
-    injectedChars: claim.length
+    confidence: 0.2,
+    exploredLines: Math.min(lines.length, HEAD_LINES2),
+    injectedChars: Math.min(structuralClaim.length, maxInjectedChars),
+    segments: [structuralSegment],
+    satisfiedRequirementIds: [],
+    unresolvedRequirementIds: requirements.map((requirement) => requirement.id),
+    provenance: {
+      contentHash: contentHash2,
+      byteCount,
+      lineCount: lines.length,
+      fileVersion,
+      exploredRanges: [
+        {
+          startLine: structuralSegment.anchor.startLine,
+          endLine: structuralSegment.anchor.endLine
+        }
+      ],
+      searchRounds,
+      truncated: true
+    }
   };
 }
-function shouldBranchRead(contentLength, lineCount, hasExplicitSmallRange, thresholdChars = 8e3) {
-  if (hasExplicitSmallRange)
-    return false;
+function shouldBranchRead(contentLength, lineCount, _hasExplicitSmallRange, thresholdChars = 8e3) {
   return contentLength > thresholdChars || lineCount > 200;
 }
-var WINDOW_LINES, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, EXTRACT_CONFIDENCE_FLOOR, STOPWORDS2;
+function estimateFileReadInjectionTokens(sourceBytes, sourceLines) {
+  const bytes = Math.max(0, Math.floor(sourceBytes));
+  const lines = Math.max(0, Math.floor(sourceLines));
+  return Math.ceil((bytes + lines * 10 + 512) / 4);
+}
+function assessBranchRead(input) {
+  const projectedReadTokens = Math.max(0, Math.ceil(input.projectedReadTokens ?? estimateFileReadInjectionTokens(input.sourceBytes, input.sourceLines)));
+  const contextWindowTokens = Math.max(0, Math.floor(input.contextWindowTokens));
+  if (contextWindowTokens <= 0) {
+    const legacy = shouldBranchRead(input.sourceBytes, input.sourceLines, false);
+    return {
+      branch: legacy,
+      reasons: legacy ? ["legacy_size"] : [],
+      projectedReadTokens,
+      fractionLimitTokens: 0,
+      availableHeadroomTokens: Number.POSITIVE_INFINITY,
+      projectedFraction: 0,
+      ...input.requestedRange ? { requestedRange: input.requestedRange } : {}
+    };
+  }
+  const fraction = Math.min(0.9, Math.max(0.01, input.maxInlineFraction ?? DEFAULT_BRANCH_READ_CONTEXT_FRACTION));
+  const fractionLimitTokens = Math.floor(contextWindowTokens * fraction);
+  const resident = Math.max(0, Math.ceil(input.residentContextTokens ?? 0));
+  const reserved = Math.max(0, Math.ceil(input.reservedTokens ?? 0));
+  const pending2 = Math.max(0, Math.ceil(input.pendingInlineReadTokens ?? 0));
+  const safeCeiling = Math.max(0, Math.min(contextWindowTokens, Math.floor(input.safeContextTokens ?? contextWindowTokens)));
+  const availableHeadroomTokens = Math.max(0, safeCeiling - resident - reserved - pending2);
+  const reasons = [];
+  if (projectedReadTokens > fractionLimitTokens)
+    reasons.push("read_fraction");
+  if (projectedReadTokens > availableHeadroomTokens)
+    reasons.push("headroom");
+  if (pending2 > 0 && pending2 + projectedReadTokens > fractionLimitTokens) {
+    reasons.push("batch_budget");
+  }
+  return {
+    branch: reasons.length > 0,
+    reasons: [...new Set(reasons)],
+    projectedReadTokens,
+    fractionLimitTokens,
+    availableHeadroomTokens,
+    projectedFraction: projectedReadTokens / contextWindowTokens,
+    ...input.requestedRange ? { requestedRange: input.requestedRange } : {}
+  };
+}
+var MAX_WINDOWS, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, EXTRACT_CONFIDENCE_FLOOR, STOPWORDS2, DEFAULT_BRANCH_READ_CONTEXT_FRACTION;
 var init_evidenceBranch = __esm({
   "packages/orchestrator/dist/evidenceBranch.js"() {
     "use strict";
-    WINDOW_LINES = 40;
+    MAX_WINDOWS = 6;
     SNIPPET_CONTEXT = 4;
     HEAD_LINES2 = 10;
     MAX_SNIPPET_LINES = 220;
@@ -583916,6 +584813,7 @@ var init_evidenceBranch = __esm({
       "report",
       "tell"
     ]);
+    DEFAULT_BRANCH_READ_CONTEXT_FRACTION = 0.2;
   }
 });
 
@@ -584338,7 +585236,7 @@ var init_prompt_cache = __esm({
 
 // packages/orchestrator/dist/git-progress.js
 import { existsSync as existsSync104, readFileSync as readFileSync80, statSync as statSync41 } from "node:fs";
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash34 } from "node:crypto";
 import { relative as relative13, resolve as resolve56, sep as sep4 } from "node:path";
 function isRunnerOwnedGitPath(path16) {
   const normalized = normalizeGitPath(path16);
@@ -584365,7 +585263,7 @@ function pathHash(repoRoot, relPath) {
     const st = statSync41(absolute);
     if (!st.isFile())
       return `non-file:${st.size}:${Math.floor(st.mtimeMs)}`;
-    return createHash33("sha256").update(readFileSync80(absolute)).digest("hex");
+    return createHash34("sha256").update(readFileSync80(absolute)).digest("hex");
   } catch {
     return void 0;
   }
@@ -585265,7 +586163,7 @@ __export(preflightSnapshot_exports, {
 import { existsSync as existsSync105, readFileSync as readFileSync81, statSync as statSync42, statfsSync as statfsSync6 } from "node:fs";
 import { homedir as homedir36, platform as platform4, arch as arch2, totalmem as totalmem4, freemem as freemem3, hostname as hostname3 } from "node:os";
 import { join as join113 } from "node:path";
-import { createHash as createHash34 } from "node:crypto";
+import { createHash as createHash35 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
@@ -585279,7 +586177,7 @@ function capturePreflightSnapshot(workingDir) {
     } catch {
       continue;
     }
-    configFingerprints[det.path] = sha2564(raw);
+    configFingerprints[det.path] = sha2565(raw);
     for (const w of det.check(raw)) {
       warnings.push({ ...w, source: expanded });
     }
@@ -585297,7 +586195,7 @@ function capturePreflightSnapshot(workingDir) {
         } catch {
           continue;
         }
-        configFingerprints[`<cwd>/${localName}`] = sha2564(raw);
+        configFingerprints[`<cwd>/${localName}`] = sha2565(raw);
         for (const w of det.check(raw)) {
           warnings.push({ ...w, source: projectPath });
         }
@@ -585433,8 +586331,8 @@ function expandPath(p2) {
     return join113(homedir36(), p2.slice(2));
   return p2;
 }
-function sha2564(s2) {
-  return createHash34("sha256").update(s2).digest("hex").slice(0, 16);
+function sha2565(s2) {
+  return createHash35("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function freeDiskBytes(path16 = "/tmp") {
   try {
@@ -586048,7 +586946,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 +587059,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
         }
       }
     ];
-    DEFAULTS2 = {
+    DEFAULTS3 = {
       warnAttempts: 3,
       criticalAttempts: 5,
       cooldownAttempts: 2,
@@ -586175,7 +587073,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 +588002,7 @@ var init_agenticRunner = __esm({
     "use strict";
     init_contextBudget();
     init_textSanitize();
+    init_text_echo_guard();
     init_permissionRuleset();
     init_steeringIntake();
     init_completionLedger();
@@ -587157,6 +588056,7 @@ var init_agenticRunner = __esm({
     init_context_fabric();
     init_context_compiler();
     init_evidenceLedger();
+    init_observationLedger();
     init_trajectory_checkpoint();
     init_adversaryStream();
     init_contextWindowDump();
@@ -587480,6 +588380,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 +588646,18 @@ var init_agenticRunner = __esm({
       // sees the evidence it already has instead of re-deriving it. See
       // evidenceLedger.ts.
       _evidenceLedger = new EvidenceLedger();
+      /**
+       * Curated branch nodes keyed by source hash + discovery contract. Raw source
+       * is deliberately absent so retries/compaction cannot rehydrate it.
+       */
+      _branchEvidenceCache = /* @__PURE__ */ new Map();
+      /** Latest curated node per canonical path for safe post-compaction recovery. */
+      _branchEvidenceByPath = /* @__PURE__ */ new Map();
+      // 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 +595205,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 +595330,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",
@@ -595563,7 +596506,31 @@ Rewrite it now for ${ctx3.model}.`;
           };
         }
         try {
-          const result = await tool.execute(args);
+          const callId = `runTool:${resolved.name}:${Date.now()}:${Math.random()}`;
+          const batchBudget = {
+            inlineTokens: 0,
+            reservations: /* @__PURE__ */ new Map()
+          };
+          const preempted = await this._preemptFileReadWithBranch({
+            callId,
+            toolName: resolved.name,
+            args,
+            messages: [],
+            turn: this._taskState.toolCallCount,
+            batchBudget
+          });
+          if (preempted)
+            return preempted;
+          let result = await tool.execute(args);
+          result = await this._guardMaterializedFileReadResult({
+            callId,
+            toolName: resolved.name,
+            args,
+            result,
+            messages: [],
+            turn: this._taskState.toolCallCount,
+            batchBudget
+          });
           return this.applyRegisteredToolResultTriage(result, resolved.name, tool);
         } catch (e2) {
           return { success: false, output: "", error: e2?.message || String(e2) };
@@ -595788,8 +596755,309 @@ ${notice}`;
           trajectoryNextAction: trajectory?.nextAction || this._taskState.nextAction,
           trajectoryOpenQuestion: trajectory?.openQuestions[0],
           currentStep: this._taskState.currentStep,
-          recentFailure
+          recentFailure,
+          goalAnchor: trajectory?.currentStep || this._taskState.currentStep || this._taskState.nextAction,
+          requestedRange: input.requestedRange,
+          projectedReadTokens: input.routingDecision?.projectedReadTokens,
+          contextWindowTokens: this._branchRoutingContextWindow(),
+          routingReason: input.routingDecision?.reasons.join(", ")
+        });
+      }
+      /** The usable total window for mandatory read routing. */
+      _branchRoutingContextWindow() {
+        const declared = Math.max(0, this.options.contextWindowSize ?? 0);
+        const effective = Math.max(0, this.effectiveContextWindow());
+        if (declared > 0 && effective > 0)
+          return Math.min(declared, effective);
+        return declared || effective;
+      }
+      _branchReadReservedTokens(contextWindow) {
+        if (contextWindow <= 0)
+          return 0;
+        const generation = Math.min(this.contextLimits().maxOutputTokens, Math.max(1024, Math.floor(contextWindow * 0.15)));
+        return generation + Math.max(512, Math.floor(contextWindow * 0.05));
+      }
+      _branchReadPath(args) {
+        for (const key of ["path", "file", "file_path", "filename", "filepath"]) {
+          const value2 = args[key];
+          if (typeof value2 === "string" && value2.trim())
+            return value2.trim();
+        }
+        return "";
+      }
+      /** Content identity used to prove an exact local read is still unchanged. */
+      _fileReadDiskIdentity(args) {
+        const path16 = this._branchReadPath(args);
+        if (!path16)
+          return null;
+        try {
+          const absolutePath = this._absoluteToolPath(path16);
+          const stat9 = _fsStatSync(absolutePath);
+          if (!stat9.isFile())
+            return null;
+          const content = _fsReadFileSync(absolutePath, "utf8");
+          return {
+            path: path16,
+            canonicalPath: this._normalizeEvidencePath(path16),
+            contentHash: _createHash("sha256").update(content).digest("hex"),
+            byteCount: stat9.size,
+            mtimeMs: stat9.mtimeMs
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Mandatory pre-dispatch router for local file reads. It resolves exactly
+       * once against the authoritative run directory, computes the actual selected
+       * range, and intercepts unsafe reads before registered tool code or any
+       * transcript/evidence consumer can observe raw content.
+       */
+      async _preemptFileReadWithBranch(input) {
+        if (this.lookupRegisteredTool(input.toolName)?.name !== "file_read") {
+          return null;
+        }
+        const rawPath = this._branchReadPath(input.args);
+        if (!rawPath)
+          return null;
+        let fullContent;
+        let stat9;
+        let absolutePath;
+        try {
+          absolutePath = this._absoluteToolPath(rawPath);
+          stat9 = _fsStatSync(absolutePath);
+          if (!stat9.isFile())
+            return null;
+          fullContent = _fsReadFileSync(absolutePath, "utf8");
+        } catch {
+          return null;
+        }
+        const allLines = fullContent.split("\n");
+        const rawOffset = input.args["offset"];
+        const rawLimit = input.args["limit"];
+        const hasRange = typeof rawOffset === "number" || typeof rawLimit === "number";
+        const offset = typeof rawOffset === "number" && Number.isFinite(rawOffset) ? Math.max(1, Math.floor(rawOffset)) : void 0;
+        const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) ? Math.max(0, Math.floor(rawLimit)) : void 0;
+        const startIndex = hasRange ? Math.max(0, (offset ?? 1) - 1) : 0;
+        const selectedLines = hasRange ? allLines.slice(startIndex, limit === void 0 ? void 0 : startIndex + limit) : allLines;
+        const selectedContent = selectedLines.join("\n");
+        const selectedBytes = Buffer.byteLength(selectedContent, "utf8");
+        const contextWindow = this._branchRoutingContextWindow();
+        const residentTokens = estimateMessagesTokens2(input.messages);
+        const reservedTokens = this._branchReadReservedTokens(contextWindow);
+        const decision2 = assessBranchRead({
+          sourceBytes: selectedBytes,
+          sourceLines: selectedLines.length,
+          contextWindowTokens: contextWindow,
+          residentContextTokens: residentTokens,
+          reservedTokens,
+          pendingInlineReadTokens: input.batchBudget.inlineTokens,
+          safeContextTokens: this.contextLimits().compactionThreshold,
+          ...hasRange ? { requestedRange: { offset, limit } } : {}
+        });
+        if (!decision2.branch) {
+          input.batchBudget.inlineTokens += decision2.projectedReadTokens;
+          input.batchBudget.reservations.set(input.callId, decision2.projectedReadTokens);
+          return null;
+        }
+        const fullHash = _createHash("sha256").update(fullContent).digest("hex");
+        const branchBrief = this._buildBranchExtractionBrief({
+          path: rawPath,
+          lineCount: selectedLines.length,
+          byteCount: selectedBytes,
+          messages: input.messages,
+          ...hasRange ? { requestedRange: { offset, limit } } : {},
+          routingDecision: decision2
+        });
+        const contractFingerprint = _createHash("sha256").update(JSON.stringify(branchBrief.discoveryContract ?? branchBrief)).digest("hex").slice(0, 20);
+        const canonicalPath = this._normalizeEvidencePath(rawPath);
+        const cacheKey = `${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
+        const cached = this._branchEvidenceCache.get(cacheKey);
+        if (cached) {
+          const duplicateBlocked = [
+            `[BRANCH-DUPLICATE-BLOCKED] path=${rawPath} sha256=${fullHash} contract=${contractFingerprint}`,
+            `The unchanged source was already branch-extracted into the current evidence ledger; the registered file_read was not executed and raw content was not re-injected.`,
+            `Use the existing curated anchors. If a required discovery is unresolved, issue one narrower grep_search or a range whose projected payload stays below the 20% limit; otherwise take the next task action.`
+          ].join("\n");
+          this.emit({
+            type: "status",
+            toolName: input.toolName,
+            content: `Branch-extract cache hit: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint}`,
+            turn: input.turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return {
+            success: true,
+            output: duplicateBlocked,
+            llmContent: duplicateBlocked,
+            beforeHash: fullHash,
+            runtimeAuthored: true,
+            noop: true,
+            completionEvidenceMetrics: {
+              branchSourceBytes: cached.sourceBytes,
+              branchCacheHit: true
+            }
+          };
+        }
+        const extractionBackend = process.env["OMNIUS_DISABLE_BRANCH_EXTRACT"] === "1" ? void 0 : this._auxInferenceBackend();
+        const ev = await extractEvidence({
+          path: rawPath,
+          query: branchBrief.retrievalQuery,
+          brief: branchBrief,
+          content: selectedContent,
+          contentHash: fullHash,
+          sourceLineOffset: startIndex,
+          fileVersion: this._worldFacts.files.get(rawPath)?.writeCount ?? 0,
+          backend: extractionBackend,
+          timeoutMs: 3e4
+        });
+        const verboseOutput = [
+          `[BRANCH-EXTRACT v2] path=${rawPath}`,
+          `routing=mandatory reasons=${decision2.reasons.join(",")} projected_read_tokens=${decision2.projectedReadTokens} fraction_limit_tokens=${decision2.fractionLimitTokens} available_headroom_tokens=${decision2.availableHeadroomTokens}`,
+          `source=sha256:${fullHash} selected_lines=${selectedLines.length} selected_bytes=${selectedBytes}${hasRange ? ` range=${offset ?? 1}:${limit ?? "EOF"}` : " range=whole"}`,
+          `[DISCOVERY CONTRACT]`,
+          `Goal anchor: ${branchBrief.discoveryContract?.goalAnchor ?? this._taskState.currentStep}`,
+          `Request: ${branchBrief.request}`,
+          `Required discoveries:`,
+          ...(branchBrief.discoveryContract?.requirements ?? []).map((requirement) => `- ${requirement.id}${requirement.required ? " [required]" : ""}: ${requirement.question}`),
+          `Stop conditions: ${(branchBrief.discoveryContract?.completionCriteria ?? []).join(" | ")}`,
+          `[CURATED SEGMENTS]`,
+          ev.claim,
+          `satisfied=${ev.satisfiedRequirementIds.join(",") || "none"}`,
+          `unresolved=${ev.unresolvedRequirementIds.join(",") || "none"}`,
+          `provenance=content:${ev.provenance.contentHash} searches:${ev.provenance.searchRounds.length} ranges:${ev.provenance.exploredRanges.map((range) => `L${range.startLine}-L${range.endLine}`).join(",")}`,
+          `Contract: use these anchors as evidence. If a required item remains unresolved, issue one narrow grep_search or bounded file_read for that item; never re-read the whole file or expand a range past the 20% budget.`
+        ].join("\n");
+        const outputBudgetChars = Math.max(800, decision2.fractionLimitTokens * 4);
+        let output = verboseOutput;
+        if (verboseOutput.length > outputBudgetChars) {
+          const required = (branchBrief.discoveryContract?.requirements ?? []).filter((requirement) => requirement.required).map((requirement) => `${requirement.id}:${requirement.question.slice(0, 180)}`).join(" | ");
+          const prefix = [
+            `[BRANCH-EXTRACT v2] path=${rawPath} sha256=${fullHash}`,
+            `routing=${decision2.reasons.join(",")} projected=${decision2.projectedReadTokens}/${contextWindow}t limit=${decision2.fractionLimitTokens}t`,
+            `[DISCOVERY CONTRACT] required=${required || "next narrow file-local fact"}`,
+            `[CURATED SEGMENTS]`
+          ].join("\n");
+          const suffix = [
+            `unresolved=${ev.unresolvedRequirementIds.join(",") || "none"}`,
+            `anchors=${ev.provenance.exploredRanges.map((range) => `L${range.startLine}-L${range.endLine}`).join(",")}`,
+            `Do not whole-read again; act on these anchors or issue one narrower search.`
+          ].join("\n");
+          const claimBudget = Math.max(120, outputBudgetChars - prefix.length - suffix.length - 2);
+          output = `${prefix}
+${ev.claim.slice(0, claimBudget)}
+${suffix}`.slice(0, outputBudgetChars);
+        }
+        this._branchEvidenceCache.set(cacheKey, {
+          output,
+          path: canonicalPath,
+          contentHash: fullHash,
+          sourceBytes: stat9.size,
+          createdAt: Date.now()
+        });
+        this._branchEvidenceByPath.set(canonicalPath, {
+          output,
+          contentHash: fullHash,
+          mtimeMs: stat9.mtimeMs
         });
+        this.emit({
+          type: "status",
+          toolName: input.toolName,
+          content: `Branch-extract preempted ${rawPath}: ${decision2.projectedReadTokens}/${contextWindow} projected tokens (${(decision2.projectedFraction * 100).toFixed(1)}%); resident=${residentTokens}t reserve=${reservedTokens}t pending_reads=${input.batchBudget.inlineTokens}t; ${selectedBytes}B → ${output.length} curated chars; reasons=${decision2.reasons.join(",")}`,
+          turn: input.turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          success: true,
+          output,
+          llmContent: output,
+          beforeHash: fullHash,
+          runtimeAuthored: true,
+          mutated: false,
+          mutatedFiles: [],
+          completionEvidenceMetrics: {
+            branchSourceBytes: stat9.size,
+            branchSelectedBytes: selectedBytes,
+            branchProjectedTokens: decision2.projectedReadTokens
+          }
+        };
+      }
+      /** Fail-safe for virtual/custom file_read tools that cannot be statted locally. */
+      async _guardMaterializedFileReadResult(input) {
+        if (this.lookupRegisteredTool(input.toolName)?.name !== "file_read") {
+          return input.result;
+        }
+        const reservedForThisCall = input.batchBudget.reservations.get(input.callId) ?? 0;
+        if (!input.result.success) {
+          if (reservedForThisCall > 0) {
+            input.batchBudget.inlineTokens = Math.max(0, input.batchBudget.inlineTokens - reservedForThisCall);
+            input.batchBudget.reservations.delete(input.callId);
+          }
+          return input.result;
+        }
+        if (!input.result.output)
+          return input.result;
+        const lines = input.result.output.split("\n");
+        const contextWindow = this._branchRoutingContextWindow();
+        const decision2 = assessBranchRead({
+          sourceBytes: Buffer.byteLength(input.result.output, "utf8"),
+          sourceLines: lines.length,
+          contextWindowTokens: contextWindow,
+          residentContextTokens: estimateMessagesTokens2(input.messages),
+          reservedTokens: this._branchReadReservedTokens(contextWindow),
+          pendingInlineReadTokens: Math.max(0, input.batchBudget.inlineTokens - reservedForThisCall),
+          safeContextTokens: this.contextLimits().compactionThreshold
+        });
+        if (!decision2.branch) {
+          if (reservedForThisCall === 0) {
+            input.batchBudget.inlineTokens += decision2.projectedReadTokens;
+            input.batchBudget.reservations.set(input.callId, decision2.projectedReadTokens);
+          }
+          return input.result;
+        }
+        if (reservedForThisCall > 0) {
+          input.batchBudget.inlineTokens = Math.max(0, input.batchBudget.inlineTokens - reservedForThisCall);
+          input.batchBudget.reservations.delete(input.callId);
+        }
+        const path16 = this._branchReadPath(input.args) || "virtual:file_read";
+        const brief = this._buildBranchExtractionBrief({
+          path: path16,
+          lineCount: lines.length,
+          byteCount: Buffer.byteLength(input.result.output, "utf8"),
+          messages: input.messages,
+          routingDecision: decision2
+        });
+        const ev = await extractEvidence({
+          path: path16,
+          query: brief.retrievalQuery,
+          brief,
+          content: input.result.output,
+          fileVersion: 0,
+          backend: process.env["OMNIUS_DISABLE_BRANCH_EXTRACT"] === "1" ? void 0 : this._auxInferenceBackend(),
+          timeoutMs: 3e4
+        });
+        const output = [
+          `[BRANCH-EXTRACT v2] path=${path16}`,
+          `routing=post-execution-failsafe reasons=${decision2.reasons.join(",")} projected_read_tokens=${decision2.projectedReadTokens}`,
+          `[DISCOVERY CONTRACT] ${brief.request}`,
+          `[CURATED SEGMENTS]`,
+          ev.claim,
+          `unresolved=${ev.unresolvedRequirementIds.join(",") || "none"}`,
+          `provenance=content:${ev.provenance.contentHash} ranges:${ev.provenance.exploredRanges.map((range) => `L${range.startLine}-L${range.endLine}`).join(",")}`
+        ].join("\n").slice(0, Math.max(800, decision2.fractionLimitTokens * 4));
+        return {
+          ...input.result,
+          output,
+          llmContent: output,
+          beforeHash: input.result.beforeHash ?? ev.provenance.contentHash,
+          runtimeAuthored: true,
+          completionEvidenceMetrics: {
+            ...input.result.completionEvidenceMetrics,
+            branchSourceBytes: Buffer.byteLength(input.result.output, "utf8"),
+            branchSelectedBytes: Buffer.byteLength(input.result.output, "utf8"),
+            branchProjectedTokens: decision2.projectedReadTokens
+          }
+        };
       }
       /**
        * Build a child-task request from the live parent state. This is the common
@@ -596448,6 +597716,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 +597882,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 +598156,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 {
@@ -597028,6 +598342,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         let completionTokens = 0;
         let estimatedTokens = 0;
         let toolCallCount = 0;
+        let substantiveProgressCount = 0;
+        const substantiveProgressFingerprints = /* @__PURE__ */ new Set();
         let completed = false;
         let summary = "";
         let bruteForceCycle = 0;
@@ -597096,6 +598412,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         let lastCommitGateTurn = -1;
         let lastShellPivotTurn = -1;
         const recentToolResults = /* @__PURE__ */ new Map();
+        const exactFileReadObservations = /* @__PURE__ */ new Map();
         let fileMutationEpoch = 0;
         const dedupHitCount = /* @__PURE__ */ new Map();
         const noopedMemoryWriteFingerprints = /* @__PURE__ */ new Set();
@@ -597500,6 +598817,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();
@@ -598931,8 +600258,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash53 } = await import("node:crypto");
-                const sig = createHash53("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash54 } = await import("node:crypto");
+                const sig = createHash54("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -599070,10 +600397,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()
           };
@@ -599268,9 +600598,7 @@ ${memoryLines.join("\n")}`
                         const parsed = JSON.parse(jsonMatch[1]);
                         const resolvedParsedTool = parsed.tool ? this.lookupRegisteredTool(parsed.tool) : null;
                         if (parsed.tool && resolvedParsedTool) {
-                          const tool = resolvedParsedTool.tool;
-                          const rawResult = await tool.execute(parsed.args ?? {});
-                          const result = this.applyRegisteredToolResultTriage(rawResult, resolvedParsedTool.name, tool);
+                          const result = await this.runToolByName(resolvedParsedTool.name, parsed.args ?? {});
                           messages2.push({ role: "assistant", content });
                           messages2.push({
                             role: "system",
@@ -599479,6 +600807,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({
@@ -599544,6 +600873,10 @@ ${memoryLines.join("\n")}`
               });
             }
             let editFeedbackRequiredBeforeMoreEdits = null;
+            const branchReadBatchBudget = {
+              inlineTokens: 0,
+              reservations: /* @__PURE__ */ new Map()
+            };
             executeSingle = async (tc) => {
               if (this.aborted)
                 return null;
@@ -600402,6 +601735,7 @@ ${cachedResult}`,
               const resolvedTool = this.lookupRegisteredTool(tc.name);
               const tool = resolvedTool?.tool;
               let result;
+              let fileReadSafetyChecked = false;
               let runtimeSystemGuidance = null;
               if (repeatShortCircuit) {
                 result = repeatShortCircuit;
@@ -600551,22 +601885,86 @@ ${cachedResult}`,
                           }
                         }
                         try {
-                          if (typeof tool.executeStream === "function") {
-                            const gen = tool.executeStream(finalArgs);
-                            let iterResult = await gen.next();
-                            while (!iterResult.done) {
-                              const progress = String(iterResult.value);
-                              this.emit({
-                                type: "status",
-                                toolName: tc.name,
-                                content: progress,
-                                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                              });
-                              iterResult = await gen.next();
+                          tc.arguments = finalArgs;
+                          const normalizedDispatchName = resolvedTool?.name ?? tc.name;
+                          let branchPreempted = null;
+                          if (normalizedDispatchName === "file_read") {
+                            const exactReadKey = this._buildToolFingerprint("file_read", tc.arguments);
+                            const priorRead = exactFileReadObservations.get(exactReadKey);
+                            if (priorRead) {
+                              const currentRead = this._fileReadDiskIdentity(tc.arguments);
+                              if (currentRead && currentRead.contentHash === priorRead.contentHash) {
+                                exactFileReadObservations.set(exactReadKey, currentRead);
+                                const duplicateOutput = [
+                                  `[DUPLICATE_READ_BLOCKED] path=${currentRead.path} sha256=${currentRead.contentHash}`,
+                                  `The exact file_read arguments already produced evidence from this unchanged source during the current run. The tool was not re-executed and the raw body was not re-injected.`,
+                                  `Use the existing evidence/anchors now. To discover something different, issue one narrower offset/limit or grep_search with a new symbol; otherwise take the next mutation, verification, or completion action.`
+                                ].join("\n");
+                                branchPreempted = {
+                                  success: true,
+                                  output: duplicateOutput,
+                                  llmContent: duplicateOutput,
+                                  beforeHash: currentRead.contentHash,
+                                  runtimeAuthored: true,
+                                  noop: true,
+                                  completionEvidenceMetrics: {
+                                    duplicateReadBlocked: true,
+                                    duplicateReadSourceBytes: currentRead.byteCount
+                                  }
+                                };
+                                this.emit({
+                                  type: "status",
+                                  toolName: normalizedDispatchName,
+                                  content: `Exact unchanged file_read blocked before dispatch: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}`,
+                                  turn,
+                                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                });
+                              } else {
+                                exactFileReadObservations.delete(exactReadKey);
+                              }
                             }
-                            result = iterResult.value;
+                          }
+                          if (!branchPreempted) {
+                            branchPreempted = await this._preemptFileReadWithBranch({
+                              callId: tc.id,
+                              toolName: normalizedDispatchName,
+                              args: tc.arguments,
+                              messages: messages2,
+                              turn,
+                              batchBudget: branchReadBatchBudget
+                            });
+                          }
+                          if (branchPreempted) {
+                            result = branchPreempted;
+                            fileReadSafetyChecked = true;
                           } else {
-                            result = await tool.execute(finalArgs);
+                            if (typeof tool.executeStream === "function") {
+                              const gen = tool.executeStream(finalArgs);
+                              let iterResult = await gen.next();
+                              while (!iterResult.done) {
+                                const progress = String(iterResult.value);
+                                this.emit({
+                                  type: "status",
+                                  toolName: tc.name,
+                                  content: progress,
+                                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                });
+                                iterResult = await gen.next();
+                              }
+                              result = iterResult.value;
+                            } else {
+                              result = await tool.execute(finalArgs);
+                            }
+                            result = await this._guardMaterializedFileReadResult({
+                              callId: tc.id,
+                              toolName: resolvedTool?.name ?? tc.name,
+                              args: tc.arguments,
+                              result,
+                              messages: messages2,
+                              turn,
+                              batchBudget: branchReadBatchBudget
+                            });
+                            fileReadSafetyChecked = true;
                           }
                           result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                           if (tc.name === "shell" && result.success === true) {
@@ -600666,6 +602064,23 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                 }
               }
+              if (!fileReadSafetyChecked) {
+                result = await this._guardMaterializedFileReadResult({
+                  callId: tc.id,
+                  toolName: resolvedTool?.name ?? tc.name,
+                  args: tc.arguments,
+                  result,
+                  messages: messages2,
+                  turn,
+                  batchBudget: branchReadBatchBudget
+                });
+              }
+              if ((resolvedTool?.name ?? tc.name) === "file_read" && result.success === true && result.noop !== true) {
+                const observedIdentity = this._fileReadDiskIdentity(tc.arguments);
+                if (observedIdentity && (!result.beforeHash || result.beforeHash === observedIdentity.contentHash)) {
+                  exactFileReadObservations.set(this._buildToolFingerprint("file_read", tc.arguments), observedIdentity);
+                }
+              }
               const shellFilesystemMutation = tc.name === "shell" && result.success === true && this._shellCommandLikelyMutatesFilesystem(String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? ""));
               this._releaseMutationWorkerLeaseForArgs(resolvedTool?.name ?? tc.name, tc.arguments, result, turn);
               const shellMutationPaths = shellFilesystemMutation ? extractShellMutationPaths(String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? ""), { workingDir: this.authoritativeWorkingDirectory() }).paths : [];
@@ -600716,6 +602131,13 @@ Respond with EXACTLY this structure before your next tool call:
                       writeCount: nextWriteCount
                     });
                     this._evidenceLedger.markMutated(this._normalizeEvidencePath(p2), nextWriteCount, turn);
+                    const branchPath = this._normalizeEvidencePath(p2);
+                    this._branchEvidenceByPath.delete(branchPath);
+                    for (const [cacheKey, cached] of this._branchEvidenceCache) {
+                      if (cached.path === branchPath) {
+                        this._branchEvidenceCache.delete(cacheKey);
+                      }
+                    }
                     {
                       const _normMut = this._normalizeEvidencePath(p2);
                       for (const _covKey of this._readCoverage.keys()) {
@@ -600755,7 +602177,7 @@ Respond with EXACTLY this structure before your next tool call:
                     const prev = this._worldFacts.files.get(p2);
                     this._worldFacts.files.set(p2, {
                       exists: result.success,
-                      size: (result.output || "").length,
+                      size: typeof result.completionEvidenceMetrics?.["branchSourceBytes"] === "number" ? result.completionEvidenceMetrics["branchSourceBytes"] : (result.output || "").length,
                       hashSample: (result.output || "").slice(0, 32),
                       lastSeenTurn: turn,
                       lastWriteTurn: prev?.lastWriteTurn,
@@ -600774,7 +602196,8 @@ Respond with EXACTLY this structure before your next tool call:
                       range: { start: start3, end },
                       fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
                       mtimeMs: this._statMtimeMsForToolPath(p2),
-                      turn
+                      turn,
+                      fidelity: result.runtimeAuthored === true && result.output.startsWith("[BRANCH-EXTRACT") ? "extract" : void 0
                     });
                   }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
@@ -601679,74 +603102,6 @@ Respond with EXACTLY this structure before your next tool call:
                 result = await this.offloadEmbeddedImageResult(result, tc.name, turn);
               }
               let output = this.normalizeToolOutput(result, tc.name, tc.arguments, turn);
-              if (process.env["OMNIUS_DISABLE_BRANCH_EXTRACT"] !== "1" && this.lookupRegisteredTool(tc.name)?.name === "file_read" && result.success && this.backend && typeof this.backend.chatCompletion === "function") {
-                const a2 = tc.arguments ?? {};
-                const hasExplicitRange = typeof a2["offset"] === "number" || typeof a2["limit"] === "number";
-                const pRaw = String(a2["path"] ?? a2["file"] ?? a2["file_path"] ?? "");
-                if (!hasExplicitRange && pRaw) {
-                  let fullContent = null;
-                  let trueLines = 0;
-                  let trueBytes = 0;
-                  for (const cand of [
-                    pRaw,
-                    _pathResolve(this._workingDirectory || process.cwd(), pRaw)
-                  ]) {
-                    try {
-                      const st = _fsStatSync(cand);
-                      if (st.isFile()) {
-                        trueBytes = st.size;
-                        if (trueBytes > 8e3) {
-                          fullContent = _fsReadFileSync(cand, "utf-8");
-                          trueLines = fullContent.split("\n").length;
-                        }
-                        break;
-                      }
-                    } catch {
-                    }
-                  }
-                  if (fullContent && shouldBranchRead(trueBytes, trueLines, false)) {
-                    const branchBrief = this._buildBranchExtractionBrief({
-                      path: pRaw,
-                      lineCount: trueLines,
-                      byteCount: trueBytes,
-                      messages: messages2
-                    });
-                    try {
-                      const ev = await extractEvidence({
-                        path: pRaw,
-                        query: branchBrief.retrievalQuery,
-                        brief: branchBrief,
-                        content: fullContent,
-                        // the REAL body, not the preview
-                        fileVersion: this._worldFacts.files.get(pRaw)?.writeCount ?? 0,
-                        // Native /api/chat so the extractor LLM fallback isn't
-                        // silently empty on qwen3-family models.
-                        backend: this._auxInferenceBackend(),
-                        timeoutMs: 3e4
-                      });
-                      output = [
-                        `[BRANCH-EXTRACT] ${pRaw} is large (${trueLines} lines, ${trueBytes} bytes); a whole-file read only returns a preview, so it was read in an isolated branch and distilled.`,
-                        `[AGENTIC EXTRACTION REQUEST] ${branchBrief.request}`,
-                        `Evidence driving this request:`,
-                        ...branchBrief.triggerEvidence.map((evidence) => `- ${evidence}`),
-                        `Looking for: ${branchBrief.returnContract}`,
-                        `Retrieval focus: "${branchBrief.retrievalQuery.slice(0, 240)}"`,
-                        `Relevant evidence (lines ${ev.sourceStart ?? "?"}-${ev.sourceEnd ?? "?"}, confidence ${ev.confidence.toFixed(2)}):`,
-                        ev.claim,
-                        `If you need a different region, call file_read with a specific offset+limit. Do NOT re-read the whole file — you already have the relevant content above.`
-                      ].join("\n");
-                      this.emit({
-                        type: "status",
-                        toolName: tc.name,
-                        content: `Branch-extract: ${pRaw} (${trueLines} lines / ${trueBytes}B) → ${ev.injectedChars} chars to context (${(trueBytes / Math.max(1, ev.injectedChars)).toFixed(0)}× smaller)`,
-                        turn,
-                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                      });
-                    } catch {
-                    }
-                  }
-                }
-              }
               if (criticGuidance && !repeatShortCircuit) {
                 output += `
 
@@ -601830,6 +603185,22 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              const branchCacheHit = result.completionEvidenceMetrics?.["branchCacheHit"] === true;
+              const nonSubstantiveResult = result.noop === true || branchCacheHit || repeatShortCircuit !== null && result.runtimeAuthored === true;
+              if (!nonSubstantiveResult) {
+                const observationFingerprint = [
+                  this._buildToolFingerprint(tc.name, tc.arguments ?? {}),
+                  result.success ? "ok" : "error",
+                  result.beforeHash ?? "",
+                  result.afterHash ?? "",
+                  realMutationPaths.join(","),
+                  this.quickHash(String(result.output ?? result.error ?? result.llmContent ?? ""))
+                ].join("|");
+                if (!substantiveProgressFingerprints.has(observationFingerprint)) {
+                  substantiveProgressFingerprints.add(observationFingerprint);
+                  substantiveProgressCount++;
+                }
+              }
               this._taskState.toolCallCount++;
               if (realFileMutation) {
                 this._lastFileWriteTurn = turn;
@@ -602959,6 +604330,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) => {
@@ -603096,24 +604491,24 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
           } catch {
           }
         }
-        let prevCycleToolCalls = toolCallCount;
+        let prevCycleSubstantiveProgress = substantiveProgressCount;
         while (!completed && !this.aborted && !this._completionIncompleteVerification && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
           bruteForceCycle++;
           const totalTurns = messages2.filter((m2) => m2.role === "assistant").length;
-          if (bruteForceCycle > 1 && toolCallCount === prevCycleToolCalls) {
+          if (bruteForceCycle > 1 && substantiveProgressCount === prevCycleSubstantiveProgress) {
             this.emit({
               type: "status",
-              content: `Stopping re-engagement — no tool call progress in cycle ${bruteForceCycle - 1}. Model may not support tool calling for this task.`,
+              content: `Stopping re-engagement — cycle ${bruteForceCycle - 1} produced no new executed fingerprint, mutation, todo transition, or verifier evidence (${toolCallCount} attempted tool calls; ${substantiveProgressCount} substantive observations).`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             break;
           }
-          prevCycleToolCalls = toolCallCount;
+          prevCycleSubstantiveProgress = substantiveProgressCount;
           consecutiveTextOnly = 0;
           consecutiveThinkOnly = 0;
           this.emit({
             type: "status",
-            content: `Re-engaging — cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} tool calls so far)`,
+            content: `Re-engaging — cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} attempted calls / ${substantiveProgressCount} substantive observations)`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           this._reg61CooldownUntilTurn = -1;
@@ -603243,10 +604638,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 +604769,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 +604946,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 +605926,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) {
@@ -606899,7 +608328,7 @@ ${telegramPersonaHead}` : stripped
           ...stickyToKeep,
           ...filteredRecent
         ];
-        const fileRecoveryBudget = Math.floor((this.options.contextWindowSize || 32768) * 0.15);
+        const fileRecoveryBudget = Math.floor((this._branchRoutingContextWindow() || 32768) * 0.15);
         const maxRecoverFiles = tier === "small" ? 3 : tier === "medium" ? 4 : 5;
         const recoveredFiles = [];
         if (this._fileRegistry.size > 0) {
@@ -606914,8 +608343,45 @@ ${telegramPersonaHead}` : stripped
           for (const [filePath, entry] of entries) {
             try {
               const { readFileSync: readFileSync144 } = await import("node:fs");
-              const content = readFileSync144(filePath, "utf8");
+              const absolutePath = this._absoluteToolPath(filePath);
+              const content = readFileSync144(absolutePath, "utf8");
               const tokenEst = Math.ceil(content.length / 4);
+              const canonicalPath = this._normalizeEvidencePath(filePath);
+              const branchNode = this._branchEvidenceByPath.get(canonicalPath);
+              const currentMtime = this._statMtimeMsForToolPath(filePath) ?? 0;
+              if (branchNode && branchNode.mtimeMs === currentMtime) {
+                const nodeTokens = Math.ceil(branchNode.output.length / 4);
+                if (recoveredTokens + nodeTokens > fileRecoveryBudget)
+                  continue;
+                result.push({
+                  role: "system",
+                  content: `<recovered-branch-evidence path="${filePath}" sha256="${branchNode.contentHash}">
+${branchNode.output}
+</recovered-branch-evidence>`
+                });
+                recoveredFiles.push(filePath);
+                recoveredTokens += nodeTokens;
+                continue;
+              }
+              const recoveryDecision = assessBranchRead({
+                sourceBytes: Buffer.byteLength(content, "utf8"),
+                sourceLines: content.split("\n").length,
+                contextWindowTokens: this._branchRoutingContextWindow(),
+                residentContextTokens: estimateMessagesTokens2(result),
+                reservedTokens: this._branchReadReservedTokens(this._branchRoutingContextWindow()),
+                pendingInlineReadTokens: recoveredTokens,
+                safeContextTokens: this.contextLimits().compactionThreshold
+              });
+              if (recoveryDecision.branch) {
+                const reference = `<recovered-file-reference path="${filePath}" status="${entry.modified ? "modified" : "read"}" routing="branch-required" projected_tokens="${recoveryDecision.projectedReadTokens}">Raw recovery suppressed by the 20% context contract; use the existing evidence ledger or issue one goal-scoped file_read.</recovered-file-reference>`;
+                const referenceTokens = Math.ceil(reference.length / 4);
+                if (recoveredTokens + referenceTokens <= fileRecoveryBudget) {
+                  result.push({ role: "system", content: reference });
+                  recoveredFiles.push(filePath);
+                  recoveredTokens += referenceTokens;
+                }
+                continue;
+              }
               if (recoveredTokens + tokenEst > fileRecoveryBudget)
                 break;
               const truncated = content.length > 8e3;
@@ -606985,6 +608451,7 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
           } catch {
           }
         }
+        const protectedRecoveryMessages = result.filter((message2) => message2.role === "system" && typeof message2.content === "string" && /^<recovered-(?:branch-evidence|file-reference|file)\b/.test(message2.content));
         const ctxWindow = this.options.contextWindowSize;
         if (ctxWindow > 0) {
           const _safetyImgPat = /\[IMAGE_BASE64:[^\]]+\]/g;
@@ -607022,6 +608489,7 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
               ...narrowedHead,
               compactionMsg,
               ...stickyToKeep,
+              ...protectedRecoveryMessages,
               ...trimmedRecent
             ];
           }
@@ -612036,7 +613504,7 @@ var init_composite_scorer = __esm({
 });
 
 // packages/orchestrator/dist/memory/materialization-policy.js
-import { createHash as createHash35 } from "node:crypto";
+import { createHash as createHash36 } from "node:crypto";
 function materializeMemoryItems(items, options2 = {}) {
   const config = options2.config ?? DEFAULT_WEIGHTING_CONFIG;
   const sorted = [...items].sort((a2, b) => b.weight - a2.weight || a2.id.localeCompare(b.id));
@@ -612173,7 +613641,7 @@ function renderPlan(decisions, includeHeader) {
     footerBlock,
     renderedText,
     memoryPrefix,
-    prefixHash: hashText(memoryPrefix),
+    prefixHash: hashText2(memoryPrefix),
     tierDistribution,
     tokensEmitted,
     tokensBaselineNoWeighting,
@@ -612273,8 +613741,8 @@ function estimateTokens4(text2) {
     return 0;
   return Math.max(1, Math.ceil(text2.length / 4));
 }
-function hashText(text2) {
-  return createHash35("sha256").update(text2).digest("hex");
+function hashText2(text2) {
+  return createHash36("sha256").update(text2).digest("hex");
 }
 var init_materialization_policy = __esm({
   "packages/orchestrator/dist/memory/materialization-policy.js"() {
@@ -612438,7 +613906,7 @@ var init_config_loader = __esm({
 });
 
 // packages/orchestrator/dist/memory/stability-tracker.js
-import { createHash as createHash36 } from "node:crypto";
+import { createHash as createHash37 } from "node:crypto";
 import { existsSync as existsSync109, mkdirSync as mkdirSync60, readFileSync as readFileSync84, writeFileSync as writeFileSync51 } from "node:fs";
 import { dirname as dirname36, join as join117 } from "node:path";
 function stabilityFilePath(repoRoot) {
@@ -612502,7 +613970,7 @@ function computeStabilityHash(item) {
     item.scope.name,
     item.topicKey
   ].join("|");
-  return createHash36("sha256").update(normalized).digest("hex");
+  return createHash37("sha256").update(normalized).digest("hex");
 }
 function normalizeContent2(content) {
   return content.replace(/\s+/g, " ").trim();
@@ -616522,10 +617990,10 @@ var init_project_arc = __esm({
 });
 
 // packages/orchestrator/dist/dedup-gate.js
-import { createHash as createHash37 } from "node:crypto";
+import { createHash as createHash38 } from "node:crypto";
 function fingerprintCall(name10, args) {
   const canon = canonicalize(args);
-  return createHash37("sha1").update(`${name10}\0${canon}`).digest("hex").slice(0, 16);
+  return createHash38("sha1").update(`${name10}\0${canon}`).digest("hex").slice(0, 16);
 }
 function canonicalize(value2) {
   if (value2 === null || typeof value2 !== "object")
@@ -627457,7 +628925,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes31, createHash: createHash53 } = __require("crypto");
+    var { randomBytes: randomBytes31, createHash: createHash54 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -628117,7 +629585,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash53("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash54("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -628484,7 +629952,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash53 } = __require("crypto");
+    var { createHash: createHash54 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -628785,7 +630253,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash53("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash54("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -635566,14 +637034,14 @@ var init_voice_session = __esm({
 });
 
 // packages/cli/src/tui/scoped-personality.ts
-import { createHash as createHash38 } from "node:crypto";
+import { createHash as createHash39 } from "node:crypto";
 import { appendFileSync as appendFileSync13, existsSync as existsSync120, mkdirSync as mkdirSync72, readFileSync as readFileSync97, writeFileSync as writeFileSync60 } from "node:fs";
 import { join as join131, resolve as resolve60 } from "node:path";
 function safeName(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
 }
 function scopeHash(scope) {
-  return createHash38("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash39("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function scopedPersonalityDir(repoRoot, kind) {
   return resolve60(repoRoot, ".omnius", "scoped-personality", kind);
@@ -635944,7 +637412,7 @@ var init_scoped_personality = __esm({
 });
 
 // packages/cli/src/tui/voice-soul.ts
-import { createHash as createHash39 } from "node:crypto";
+import { createHash as createHash40 } from "node:crypto";
 import { existsSync as existsSync121, readdirSync as readdirSync38, readFileSync as readFileSync98 } from "node:fs";
 import { basename as basename26, join as join132, resolve as resolve61 } from "node:path";
 function compactText(text2, limit) {
@@ -635959,7 +637427,7 @@ function blockText(text2, limit) {
 ... [truncated]`;
 }
 function scopeStateKey(scope, surface) {
-  return createHash39("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash40("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function safeName2(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
@@ -638599,7 +640067,7 @@ var init_types3 = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes23, scryptSync as scryptSync2, createHash as createHash40 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes23, scryptSync as scryptSync2, createHash as createHash41 } from "node:crypto";
 import { readFileSync as readFileSync100, writeFileSync as writeFileSync62, existsSync as existsSync123, mkdirSync as mkdirSync74 } from "node:fs";
 import { dirname as dirname39 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -638843,7 +640311,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash40("sha256");
+        const hash = createHash41("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -638858,7 +640326,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter9 } from "node:events";
 import { createServer as createServer6 } from "node:http";
-import { randomBytes as randomBytes24, createHash as createHash41, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes24, createHash as createHash42, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -638874,7 +640342,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash41("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash42("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes24(24).toString("base64url");
@@ -640240,7 +641708,7 @@ __export(omnius_directory_exports, {
 import { appendFileSync as appendFileSync14, cpSync as cpSync2, existsSync as existsSync125, mkdirSync as mkdirSync76, readFileSync as readFileSync102, writeFileSync as writeFileSync64, readdirSync as readdirSync41, statSync as statSync51, unlinkSync as unlinkSync23, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync11, watch as fsWatch2 } from "node:fs";
 import { join as join136, relative as relative17, basename as basename27, dirname as dirname40, resolve as resolve62 } from "node:path";
 import { homedir as homedir42 } from "node:os";
-import { createHash as createHash43 } from "node:crypto";
+import { createHash as createHash44 } from "node:crypto";
 function isGitRoot(dir) {
   const gitPath = join136(dir, ".git");
   if (!existsSync125(gitPath)) return false;
@@ -640738,7 +642206,7 @@ function buildHandoffPrompt(repoRoot) {
   return lines.join("\n");
 }
 function computeDedupeHash(task, savedAt) {
-  return createHash43("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+  return createHash44("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -647365,7 +648833,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 +648850,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
@@ -668323,7 +669800,7 @@ __export(commands_exports, {
 });
 import * as nodeOs from "node:os";
 import { spawn as nodeSpawn2 } from "node:child_process";
-import { createHash as createHash44 } from "node:crypto";
+import { createHash as createHash45 } from "node:crypto";
 import {
   existsSync as existsSync147,
   readFileSync as readFileSync119,
@@ -681683,7 +683160,7 @@ async function collectSponsorMediaStream(args) {
     };
   }
   if (artifact.sha256) {
-    const sha = createHash44("sha256").update(bytes).digest("hex");
+    const sha = createHash45("sha256").update(bytes).digest("hex");
     if (sha !== artifact.sha256)
       return { ok: false, error: `Artifact hash mismatch for ${artifactId}` };
   }
@@ -688309,6 +689786,18 @@ var init_stream_renderer = __esm({
        * runs. Tracked in VISIBLE chars (ANSI escapes stripped).
        */
       _cursorCol = 0;
+      /**
+       * RESIZE-REWRAP: raw (un-highlighted) text of the CURRENT in-progress
+       * logical content line — everything streamed since the last "\n",
+       * including already-flushed partials. Streaming hard-breaks rows at the
+       * width current at flush time, so without this raw copy a SIGWINCH left
+       * the in-progress line "locked" at the old width (the reported artifact).
+       * onResize() erases the line's visual rows and re-emits from this buffer
+       * wrapped at the new width.
+       */
+      _currentLineRaw = "";
+      /** Visual rows (newlines) already emitted for the current logical line. */
+      _wrapRowsEmitted = 0;
       /** Called when a new model response starts streaming */
       onStreamStart() {
         this.lineBuffer = "";
@@ -688320,6 +689809,8 @@ var init_stream_renderer = __esm({
         this.jsonBlobSize = 0;
         this.jsonBlobSuppressed = false;
         this._cursorCol = 0;
+        this._currentLineRaw = "";
+        this._wrapRowsEmitted = 0;
         this.enabled = true;
         this.tokenCount = 0;
         this.startTime = Date.now();
@@ -688408,6 +689899,34 @@ var init_stream_renderer = __esm({
           process.stdout.write("\n");
           this.lineStarted = false;
         }
+        this._currentLineRaw = "";
+        this._wrapRowsEmitted = 0;
+        this._cursorCol = 0;
+      }
+      /**
+       * RESIZE-REWRAP: re-render the in-progress logical content line at the new
+       * terminal width. Streaming hard-breaks rows at flush-time width, so after
+       * a SIGWINCH the current line was left "locked" at the old width — wrapped
+       * rows missing the pipe gutter or overflowing. Erases the rows this line
+       * occupies (tracked in _wrapRowsEmitted) and re-emits from the raw buffer.
+       * Completed lines live in terminal scrollback and are not repainted.
+       * Call AFTER setTermSize() so termCols() reflects the new width.
+       */
+      onResize() {
+        if (!this.enabled) return;
+        const raw = this._currentLineRaw;
+        if (!raw) return;
+        if (isTTY8) {
+          const rowsUp = Math.min(this._wrapRowsEmitted, 40);
+          let seq = "\r\x1B[2K";
+          for (let i2 = 0; i2 < rowsUp; i2++) seq += "\x1B[A\x1B[2K";
+          process.stdout.write(`\x1B[?25l\x1B[?7l${seq}\x1B[?7h`);
+        }
+        this._cursorCol = 0;
+        this.lineStarted = false;
+        this._currentLineRaw = "";
+        this._wrapRowsEmitted = 0;
+        this.writeHighlighted(raw, "content");
       }
       /** Called when streaming ends for this response */
       onStreamEnd() {
@@ -688448,6 +689967,9 @@ var init_stream_renderer = __esm({
           if (this.lineStarted) {
             process.stdout.write("\n");
             this.lineStarted = false;
+            this._currentLineRaw = "";
+            this._wrapRowsEmitted = 0;
+            this._cursorCol = 0;
           }
           return;
         }
@@ -688517,6 +690039,14 @@ var init_stream_renderer = __esm({
             this.jsonBlobSuppressed = false;
           }
         }
+        const trackedContent = kind === "content" && !this.inCodeBlock && !this.looksLikeJson(raw);
+        if (trackedContent) this._currentLineRaw += raw;
+        const endTrackedLine = () => {
+          if (trackedContent && hasNewline) {
+            this._currentLineRaw = "";
+            this._wrapRowsEmitted = 0;
+          }
+        };
         const prefix = this.lineStarted ? "" : "  │  ";
         const maxW = Math.max(10, termCols() - 6);
         let rendered;
@@ -688527,6 +690057,7 @@ var init_stream_renderer = __esm({
             const firstChunkLen = Math.min(text3.length, Math.max(1, remaining));
             if (remaining < 8 && text3.length > remaining) {
               this.writeRaw("\n");
+              if (trackedContent) this._wrapRowsEmitted++;
               this.lineStarted = false;
             } else if (text3.length > remaining) {
               const window2 = text3.slice(0, firstChunkLen);
@@ -688535,12 +690066,13 @@ var init_stream_renderer = __esm({
               const head = text3.slice(0, wb).replace(/\s+$/, "");
               const tail = text3.slice(wb).replace(/^\s+/, "");
               this.writeRaw(highlight(head) + "\n");
+              if (trackedContent) this._wrapRowsEmitted++;
               this.lineStarted = false;
               text3 = tail;
               if (!text3) return;
             }
           }
-          const usePrefix = this.lineStarted && this._cursorCol > 0 ? "" : prefix;
+          const usePrefix = this.lineStarted && this._cursorCol > 0 ? "" : "  │  ";
           const usableW = this.lineStarted ? maxW : Math.max(1, maxW - usePrefix.length);
           const lines = text3.length > usableW ? this.wordWrap(text3, usableW) : [text3];
           const isBlockquote = kind === "content" && /^>\s/.test(text3);
@@ -688553,12 +690085,14 @@ var init_stream_renderer = __esm({
             this.writeRaw(
               dimText(lp) + highlight(chunk) + (needsNewline ? "\n" : "")
             );
+            if (trackedContent && needsNewline) this._wrapRowsEmitted++;
           }
           this.lineStarted = !trailingNewline;
         };
         switch (kind) {
           case "thinking":
             emitWrapped(raw, dimItalic, hasNewline);
+            endTrackedLine();
             return;
           case "tool_args":
             rendered = this.highlightJson(raw, true);
@@ -688582,6 +690116,7 @@ var init_stream_renderer = __esm({
             } else {
               if (visibleLength(raw) > maxW || this.lineStarted && this._cursorCol + visibleLength(raw) > maxW) {
                 emitWrapped(raw, (s2) => this.highlightMarkdown(s2), hasNewline);
+                endTrackedLine();
                 return;
               }
               rendered = this.highlightMarkdown(raw);
@@ -688591,10 +690126,12 @@ var init_stream_renderer = __esm({
         }
         if (kind === "content" && this.lineStarted && this._cursorCol + visibleLength(raw) > maxW) {
           emitWrapped(raw, (s2) => this.highlightMarkdown(s2), hasNewline);
+          endTrackedLine();
           return;
         }
         this.writeRaw(dimText(prefix) + rendered + (hasNewline ? "\n" : ""));
         this.lineStarted = !hasNewline;
+        endTrackedLine();
       }
       /** In-place update of the compact thinking box content row (cursor-up + rewrite) */
       updateThinkingBox(text2, width) {
@@ -696151,7 +697688,7 @@ import {
   unlinkSync as unlinkSync34
 } from "node:fs";
 import { join as join168 } from "node:path";
-import { createHash as createHash45 } from "node:crypto";
+import { createHash as createHash46 } from "node:crypto";
 function safeFilePart(value2) {
   return value2.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 80) || "telegram";
 }
@@ -696159,7 +697696,7 @@ function daydreamRoot(repoRoot) {
   return join168(repoRoot, ".omnius", "telegram-daydreams");
 }
 function sessionDir(repoRoot, sessionKey) {
-  const hash = createHash45("sha1").update(sessionKey).digest("hex").slice(0, 20);
+  const hash = createHash46("sha1").update(sessionKey).digest("hex").slice(0, 20);
   return join168(daydreamRoot(repoRoot), safeFilePart(hash));
 }
 function compactLine2(value2, max = 220) {
@@ -696270,7 +697807,7 @@ function buildReplyOpportunities(input, openQuestions) {
   return opportunities;
 }
 function daydreamOpportunityId(input, trigger) {
-  return createHash45("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
+  return createHash46("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
 function clamp0115(value2) {
   if (!Number.isFinite(value2)) return 0;
@@ -696675,7 +698212,7 @@ function buildTelegramChannelDaydream(input, corpus, extraction, extractionCommi
   const seed = `${input.sessionKey}:${input.generatedAtMs}:${input.history.length}`;
   return {
     version: 3,
-    id: createHash45("sha1").update(seed).digest("hex").slice(0, 16),
+    id: createHash46("sha1").update(seed).digest("hex").slice(0, 16),
     sessionKey: input.sessionKey,
     chatId: input.chatId,
     chatTitle: input.chatTitle,
@@ -696987,12 +698524,12 @@ var init_telegram_channel_dmn = __esm({
 });
 
 // packages/cli/src/tui/telegram-reflection-corpus.ts
-import { createHash as createHash46 } from "node:crypto";
+import { createHash as createHash47 } from "node:crypto";
 function telegramReflectionMemoryDbPaths(repoRoot) {
   return omniusMemoryDbPaths(repoRoot);
 }
 function stableHash2(value2, length4 = 16) {
-  return createHash46("sha1").update(value2).digest("hex").slice(0, length4);
+  return createHash47("sha1").update(value2).digest("hex").slice(0, length4);
 }
 function clean3(value2) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim();
@@ -697805,7 +699342,7 @@ var init_telegram_reflection_extraction = __esm({
 });
 
 // packages/cli/src/tui/telegram-social-state-types.ts
-import { createHash as createHash47 } from "node:crypto";
+import { createHash as createHash48 } from "node:crypto";
 function telegramSocialActorKey(actor) {
   if (!actor) return "unknown";
   if (typeof actor.userId === "number") return `user:${actor.userId}`;
@@ -697838,7 +699375,7 @@ function appendUnique(items, value2, max) {
   return next.slice(-max);
 }
 function hashTelegramSocialId(parts) {
-  return createHash47("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
+  return createHash48("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
 }
 function cleanUsername(value2) {
   if (typeof value2 !== "string") return void 0;
@@ -698898,7 +700435,7 @@ import {
 } from "node:path";
 import { homedir as homedir56 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash48, randomBytes as randomBytes28, randomInt } from "node:crypto";
+import { createHash as createHash49, randomBytes as randomBytes28, randomInt } from "node:crypto";
 function formatModelBytes(bytes) {
   if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
   const units = ["B", "KB", "MB", "GB", "TB"];
@@ -700143,7 +701680,7 @@ function buildTelegramRuntimeContext(now2 = /* @__PURE__ */ new Date(), repoRoot
   return buildConversationRuntimeContext(now2, repoRoot);
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash48("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash49("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function normalizeTelegramSubAgentLimit(value2) {
   const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && value2.trim() ? Number(value2.trim()) : TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
@@ -702307,7 +703844,7 @@ Telegram link integrity contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash48("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash49("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
@@ -704379,11 +705916,11 @@ ${mediaContext}` : ""
         return payload;
       }
       telegramConversationPath(sessionKey) {
-        const safe = createHash48("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash49("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join170(this.telegramConversationDir, `${safe}.json`);
       }
       telegramConversationLedgerPath(sessionKey) {
-        const safe = createHash48("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash49("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join170(this.telegramConversationDir, `${safe}.events.jsonl`);
       }
       telegramDb() {
@@ -704616,7 +706153,7 @@ ${mediaContext}` : ""
           relationships: Array.isArray(raw.relationships) ? raw.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
           actions: Array.isArray(raw.actions) ? raw.actions.slice(-TELEGRAM_ASSOCIATIVE_ACTION_LIMIT).map((action) => ({
             id: String(
-              action.id || createHash48("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)
+              action.id || createHash49("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)
             ),
             ts: typeof action.ts === "number" ? action.ts : Date.now(),
             role: action.role === "assistant" ? "assistant" : "user",
@@ -704635,7 +706172,7 @@ ${mediaContext}` : ""
         const now2 = Date.now();
         return {
           id: String(
-            raw.id || createHash48("sha1").update(text2 || String(now2)).digest("hex").slice(0, 12)
+            raw.id || createHash49("sha1").update(text2 || String(now2)).digest("hex").slice(0, 12)
           ),
           text: text2,
           tags: Array.isArray(raw.tags) ? raw.tags.map(String).slice(0, 16) : [],
@@ -705092,7 +706629,7 @@ ${mediaContext}` : ""
       telegramHistoryBackfillMessageId(sessionKey, entry, index) {
         if (typeof entry.messageId === "number" && Number.isFinite(entry.messageId))
           return entry.messageId;
-        const digest3 = createHash48("sha1").update(
+        const digest3 = createHash49("sha1").update(
           `${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`
         ).digest("hex").slice(0, 8);
         return -Number.parseInt(digest3, 16);
@@ -706282,7 +707819,7 @@ ${mediaContext}` : ""
         const now2 = entry.ts ?? Date.now();
         memory.updatedAt = now2;
         const speaker = telegramHistorySpeaker(entry);
-        const actionId = createHash48("sha1").update(
+        const actionId = createHash49("sha1").update(
           `${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now2}:${entry.text}`
         ).digest("hex").slice(0, 16);
         if (!memory.actions.some((action) => action.id === actionId)) {
@@ -706445,7 +707982,7 @@ ${mediaContext}` : ""
         let fact = facts.find((item) => item.text.toLowerCase() === key);
         if (!fact) {
           fact = {
-            id: createHash48("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            id: createHash49("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
             text: clean5,
             tags: telegramMemoryTags(clean5, entry.mediaSummary),
             speakers: [],
@@ -706530,7 +708067,7 @@ ${mediaContext}` : ""
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash48("sha1").update(`${sessionKey}:${now2}:${speaker}:${text2}`).digest("hex").slice(0, 12),
+            id: createHash49("sha1").update(`${sessionKey}:${now2}:${speaker}:${text2}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -709294,7 +710831,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash48("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash49("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join170(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -717693,13 +719230,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"
   };
 }
@@ -719989,14 +721526,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash49 } from "node:crypto";
+import { createHash as createHash50 } from "node:crypto";
 import { existsSync as existsSync162, mkdirSync as mkdirSync100, readFileSync as readFileSync133, renameSync as renameSync16, writeFileSync as writeFileSync87, unlinkSync as unlinkSync37 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
 import { join as join172, resolve as resolve75 } from "node:path";
 import { randomUUID as randomUUID20 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve75(root);
-  return createHash49("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash50("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join172(PROJECTS_DIR, projectKey(root));
@@ -720287,7 +721824,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash50 } from "node:crypto";
+import { createHash as createHash51 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -720350,7 +721887,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash50("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash51("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req3, res, etag) {
@@ -739761,7 +741298,7 @@ import {
   closeSync as closeSync6
 } from "node:fs";
 import { randomBytes as randomBytes29, randomUUID as randomUUID21, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { createHash as createHash51 } from "node:crypto";
+import { createHash as createHash52 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join183(baseDir, ".omnius");
   return {
@@ -747930,7 +749467,7 @@ function listScheduledTasks() {
                 );
                 const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
                 const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-                const fallbackId = createHash51("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+                const fallbackId = createHash52("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
                 const uid = realId || fallbackId;
                 const key = `${uid}`;
                 if (seen.has(key)) return;
@@ -748068,8 +749605,8 @@ function deleteScheduledById(id2) {
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id))
       candidates.push(entry.id);
     try {
-      const { createHash: createHash53 } = require4("node:crypto");
-      const fallback = createHash53("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash54 } = require4("node:crypto");
+      const fallback = createHash54("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -750306,7 +751843,7 @@ import { cwd } from "node:process";
 import { resolve as resolve78, join as join185, dirname as dirname56, extname as extname22, relative as relative22, sep as sep7 } from "node:path";
 import { createRequire as createRequire9 } from "node:module";
 import { fileURLToPath as fileURLToPath24 } from "node:url";
-import { createHash as createHash52 } from "node:crypto";
+import { createHash as createHash53 } from "node:crypto";
 import {
   readFileSync as readFileSync142,
   writeFileSync as writeFileSync94,
@@ -751240,7 +752777,7 @@ function truncateSubAgentViewText(s2, n2) {
   return s2.length > n2 ? `${s2.slice(0, n2)}…` : s2;
 }
 function childAgentTaskHash(task) {
-  return createHash52("sha256").update(task).digest("hex").slice(0, 12);
+  return createHash53("sha256").update(task).digest("hex").slice(0, 12);
 }
 function stripAnsiForParentContext(value2) {
   return value2.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
@@ -756345,6 +757882,12 @@ This is an independent background session started from /background.`
   process.stdout.on("resize", () => {
     statusBar.handleResize();
     setTermSize(process.stdout.rows ?? 24, process.stdout.columns ?? 80);
+    if (!isNeovimActive()) {
+      try {
+        streamRenderer.onResize();
+      } catch {
+      }
+    }
     if (isNeovimActive()) {
       const contentRows = statusBar.isActive ? statusBar.availableContentRows : Math.max(5, termRows() - 6);
       resizeNeovim(termCols(), contentRows);
@@ -760561,13 +762104,13 @@ ${taskInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash53 } = await import("node:crypto");
+          const { createHash: createHash54 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash53("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash54("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,