omnius 1.0.546 → 1.0.548

package/dist/index.js

@@ -6559,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));
@@ -6572,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) {
@@ -6600,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(``);
@@ -6656,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: {
@@ -6701,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 {
@@ -6716,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: [],
@@ -119450,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();
@@ -119761,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;
@@ -124395,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();
       }
@@ -262448,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();
@@ -263108,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;
@@ -263475,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();
@@ -263776,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",
@@ -276583,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 {
@@ -276722,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,
@@ -276805,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 {
@@ -566192,6 +566228,31 @@ var init_textSanitize = __esm({
 });
 
 // packages/orchestrator/dist/text-echo-guard.js
+function parseFloatEnv(name10, fallback, min, max) {
+  const raw = process.env[name10];
+  if (raw == null || raw.trim().length === 0)
+    return fallback;
+  const parsed = Number.parseFloat(raw);
+  if (!Number.isFinite(parsed))
+    return fallback;
+  return Math.min(max, Math.max(min, parsed));
+}
+function parseIntEnv(name10, fallback, min, max) {
+  const raw = process.env[name10];
+  if (raw == null || raw.trim().length === 0)
+    return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed))
+    return fallback;
+  return Math.min(max, Math.max(min, parsed));
+}
+function readTextEchoGuardOptionsFromEnv() {
+  return {
+    similarityThreshold: parseFloatEnv("OMNIUS_TEXT_ECHO_SIMILARITY_THRESHOLD", DEFAULTS.similarityThreshold, 0, 1),
+    minLength: parseIntEnv("OMNIUS_TEXT_ECHO_MIN_LENGTH", DEFAULTS.minLength, 1, 8192),
+    window: parseIntEnv("OMNIUS_TEXT_ECHO_WINDOW", DEFAULTS.window, 1, 64)
+  };
+}
 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();
 }
@@ -577071,6 +577132,7 @@ var init_streaming_executor = __esm({
       reset() {
         this.tools.clear();
         this.insertionOrder = [];
+        this.executeFn = null;
       }
       // ─────────────────────────────────────────────────────────
       // Internal — Hannover-aligned concurrency control
@@ -578943,9 +579005,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,
@@ -584082,6 +584146,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([
@@ -584091,37 +584156,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;
@@ -584207,7 +584310,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
   }));
 }
@@ -584222,6 +584327,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,
@@ -584231,8 +584338,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)
@@ -584256,127 +584365,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;
@@ -584414,6 +584838,7 @@ var init_evidenceBranch = __esm({
       "report",
       "tell"
     ]);
+    DEFAULT_BRANCH_READ_CONTEXT_FRACTION = 0.2;
   }
 });
 
@@ -584836,7 +585261,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);
@@ -584863,7 +585288,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;
   }
@@ -585763,7 +586188,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 = {};
@@ -585777,7 +586202,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 });
     }
@@ -585795,7 +586220,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 });
         }
@@ -585931,8 +586356,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 {
@@ -587992,7 +588417,7 @@ var init_agenticRunner = __esm({
       // 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();
+      _textEchoGuard = new TextEchoGuard(readTextEchoGuardOptionsFromEnv());
       // 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.
@@ -588246,6 +588671,13 @@ 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 —
@@ -596099,7 +596531,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) };
@@ -596324,8 +596780,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
@@ -597610,6 +598367,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;
@@ -597678,6 +598437,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();
@@ -599523,8 +600283,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",
@@ -599863,9 +600623,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",
@@ -600140,6 +600898,10 @@ ${memoryLines.join("\n")}`
               });
             }
             let editFeedbackRequiredBeforeMoreEdits = null;
+            const branchReadBatchBudget = {
+              inlineTokens: 0,
+              reservations: /* @__PURE__ */ new Map()
+            };
             executeSingle = async (tc) => {
               if (this.aborted)
                 return null;
@@ -600998,6 +601760,7 @@ ${cachedResult}`,
               const resolvedTool = this.lookupRegisteredTool(tc.name);
               const tool = resolvedTool?.tool;
               let result;
+              let fileReadSafetyChecked = false;
               let runtimeSystemGuidance = null;
               if (repeatShortCircuit) {
                 result = repeatShortCircuit;
@@ -601147,22 +601910,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) {
@@ -601262,6 +602089,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 : [];
@@ -601312,6 +602156,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()) {
@@ -601351,7 +602202,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,
@@ -601370,7 +602221,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) {
@@ -602275,74 +603127,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 += `
 
@@ -602426,6 +603210,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;
@@ -603716,24 +604516,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;
@@ -607553,7 +608353,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) {
@@ -607568,8 +608368,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;
@@ -607639,6 +608476,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;
@@ -607676,6 +608514,7 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
               ...narrowedHead,
               compactionMsg,
               ...stickyToKeep,
+              ...protectedRecoveryMessages,
               ...trimmedRecent
             ];
           }
@@ -612690,7 +613529,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));
@@ -612928,7 +613767,7 @@ function estimateTokens4(text2) {
   return Math.max(1, Math.ceil(text2.length / 4));
 }
 function hashText2(text2) {
-  return createHash35("sha256").update(text2).digest("hex");
+  return createHash36("sha256").update(text2).digest("hex");
 }
 var init_materialization_policy = __esm({
   "packages/orchestrator/dist/memory/materialization-policy.js"() {
@@ -613092,7 +613931,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) {
@@ -613156,7 +613995,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();
@@ -617176,10 +618015,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")
@@ -628111,7 +628950,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();
@@ -628771,7 +629610,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;
@@ -629138,7 +629977,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();
@@ -629439,7 +630278,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",
@@ -632905,6 +633744,7 @@ __export(render_exports, {
   setContentWriteHook: () => setContentWriteHook,
   setEmojisEnabled: () => setEmojisEnabled,
   stripTrustTierWrapperForTui: () => stripTrustTierWrapperForTui,
+  summarizeInternalControlOutput: () => summarizeInternalControlOutput,
   ui: () => ui
 });
 function stdoutIsTTY() {
@@ -633559,6 +634399,186 @@ function sanitizeToolBoxContent(text2) {
   }
   return out;
 }
+function compactForDisplay(text2, max = 170) {
+  const clean5 = text2.replace(/\s+/g, " ").trim();
+  return clean5.length <= max ? clean5 : `${clean5.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function parseAssignmentMap(line) {
+  const out = {};
+  const assignmentRe = /(\w+)=([^\s]+)/g;
+  let m2;
+  while ((m2 = assignmentRe.exec(line)) !== null) {
+    out[m2[1].toLowerCase()] = m2[2];
+  }
+  return out;
+}
+function extractFirstMatch(lines, pattern) {
+  for (const line of lines) {
+    const match = line.match(pattern);
+    if (match?.[1]) return match[1].trim();
+  }
+  return "";
+}
+function formatBranchExtractSummary(output) {
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) return null;
+  const first2 = lines[0].toLowerCase();
+  const isBranchExtract = first2.startsWith("[branch-extract") || first2.startsWith("[branch-duplicate-blocked]");
+  if (!isBranchExtract) return null;
+  const routingLine = lines.find((line) => line.toLowerCase().startsWith("routing=")) || "";
+  const assignment = parseAssignmentMap(routingLine);
+  const route = assignment.routing ?? "mandatory";
+  const reasons = assignment.reasons?.split(",").map((r2) => r2.trim()).filter(Boolean).join(", ") || "context protection";
+  const projected = assignment.projected_read_tokens || assignment.projectedreadtokens || assignment.projected;
+  const fractionLimit = assignment.fraction_limit_tokens || assignment.fractionlimittokens || assignment.fraction_limit || "";
+  const available = assignment.available_headroom_tokens || assignment.available_headroom;
+  const path16 = extractFirstMatch(
+    lines,
+    /(?:^|\s)path=(\S+)/
+  ) || extractFirstMatch(lines, /\[branch-extract[^\]]*?\]\s*path=([^\s]+)/) || "unknown path";
+  const discoveryStart = lines.findIndex(
+    (line) => /^\[discovery contract\]/i.test(line)
+  );
+  const curatedStart = lines.findIndex(
+    (line) => /^\[curated segments\]/i.test(line)
+  );
+  let goalAnchor = "";
+  let request = "";
+  const required = [];
+  let inRequired = false;
+  let stopCondition = "";
+  if (discoveryStart >= 0) {
+    for (let i2 = discoveryStart + 1; i2 < lines.length; i2 += 1) {
+      const line = lines[i2];
+      if (/^\[curated segments\]/i.test(line)) break;
+      if (/^Goal anchor:/i.test(line)) {
+        goalAnchor = line.replace(/^Goal anchor:\s*/i, "");
+        continue;
+      }
+      if (/^Request:/i.test(line)) {
+        request = line.replace(/^Request:\s*/i, "");
+        inRequired = false;
+        continue;
+      }
+      if (/^Stop conditions?:/i.test(line)) {
+        stopCondition = line.replace(/^Stop conditions?:\s*/i, "");
+        inRequired = false;
+        continue;
+      }
+      if (/^Required discoveries:/i.test(line)) {
+        inRequired = true;
+        continue;
+      }
+      if (inRequired && line.startsWith("- ")) {
+        required.push(line.replace(/^- /, "").slice(0, 170));
+      }
+    }
+  }
+  let curatedSummary = "";
+  let unresolved = "";
+  let satisfied = "";
+  let provenance = "";
+  if (curatedStart >= 0) {
+    for (let i2 = curatedStart + 1; i2 < lines.length; i2 += 1) {
+      const line = lines[i2];
+      if (/^satisfied=/i.test(line) || /^unresolved=/i.test(line) || /^provenance=/i.test(line)) {
+        if (line.startsWith("satisfied=")) {
+          satisfied = line.replace(/^satisfied=/i, "");
+        } else if (line.startsWith("unresolved=")) {
+          unresolved = line.replace(/^unresolved=/i, "");
+        } else if (line.startsWith("provenance=")) {
+          provenance = line.replace(/^provenance=/i, "");
+        }
+        continue;
+      }
+      if (/^Contract:/i.test(line)) {
+        continue;
+      }
+      if (curatedSummary.length < 240) {
+        curatedSummary = curatedSummary ? `${curatedSummary} ${compactForDisplay(line, 120)}` : compactForDisplay(line, 120);
+      }
+    }
+  }
+  const isDuplicate = /^\[branch-duplicate-blocked\]/i.test(lines[0]);
+  const header = isDuplicate ? "Branch-extract duplicate reuse" : "Branch-extract preempted";
+  const whatHappened = isDuplicate ? "a cache-safe duplicate was detected" : "read was auto-summarized before injecting into context";
+  const out = [
+    `↳ ${header}`,
+    `  ├ what happened: ${whatHappened}`,
+    `  ├ why: ${compactForDisplay(reasons, 140)}`,
+    `  ├ path: ${compactForDisplay(path16, 140)}`,
+    `  ├ decision scope: ${route}`
+  ];
+  if (projected) {
+    const projectedText = fractionLimit ? `${projected} projected → ${fractionLimit} limit` : `${projected} projected`;
+    const availText = available ? `; available headroom ${available}` : "";
+    out.push(`  ├ budget: ${projectedText}${availText}`);
+  }
+  if (goalAnchor) out.push(`  ├ goal anchor: ${compactForDisplay(goalAnchor, 120)}`);
+  if (request) out.push(`  ├ request: ${compactForDisplay(request, 150)}`);
+  if (required.length > 0) {
+    out.push(`  ├ required: ${compactForDisplay(required.slice(0, 3).join(", "), 180)}`);
+  }
+  if (stopCondition) {
+    out.push(`  ├ stop: ${compactForDisplay(stopCondition, 140)}`);
+  }
+  if (curatedSummary) {
+    out.push(`  ├ curated segment: ${compactForDisplay(curatedSummary, 180)}`);
+  }
+  if (satisfied || unresolved) {
+    out.push(
+      `  ├ state: satisfied=${compactForDisplay(satisfied || "none", 90)}; unresolved=${compactForDisplay(unresolved || "none", 90)}`
+    );
+  }
+  if (provenance) {
+    out.push(`  ├ provenance: ${compactForDisplay(provenance, 120)}`);
+  }
+  if (out.length > 1) {
+    const last2 = out.length - 1;
+    out[last2] = out[last2]?.replace(/^  ├ /, "  └ ") ?? out[last2];
+  }
+  return out.length > 0 ? out : null;
+}
+function formatSupersededPlanSummary() {
+  return [
+    "↳ Mode-collapse guard",
+    "  ├ what happened: near-duplicate assistant plan was suppressed",
+    "  ├ why: loop prevention to stop re-entering the same plan text",
+    "  └ next action: tool call or concrete evidence request before restating the plan"
+  ];
+}
+function formatEchoGuardSummary(output) {
+  const lower = output.toLowerCase();
+  const match = output.match(/echo-1:\s*text-only echo\s*#?(\d+)/i);
+  const echoCount = match?.[1] ? `#${match[1]}` : "";
+  const similarityMatch = output.match(/(\d+)% similar/);
+  const similarity3 = similarityMatch?.[1] ? ` (${similarityMatch[1]}% similar to earlier response)` : "";
+  const collapsed = output.match(/collapsed\s+(\d+)\s+duplicate/);
+  const duplicates = collapsed?.[1] ? `${collapsed[1]} duplicate(s) collapsed` : "";
+  const out = [
+    `↳ ECHO-1 mode-collapse guard${echoCount ? ` ${echoCount}` : ""}${similarity3}`,
+    "  ├ what happened: repeated text-only plan was intercepted",
+    "  ├ why: duplicate plan text was detected from the model loop",
+    `  ├ action: pattern-breaker${duplicates ? ` (${duplicates})` : ""}`,
+    "  └ next action: resume with tool-backed evidence"
+  ];
+  return out;
+}
+function summarizeInternalControlOutput(output) {
+  if (!output) return null;
+  const firstLine = output.split(/\r?\n/)[0]?.trim().toLowerCase() ?? "";
+  const lower = output.toLowerCase();
+  if (firstLine.includes("[branch-extract") || firstLine.includes("[branch-duplicate-blocked]") || lower.includes("branch-extract preempted")) {
+    return formatBranchExtractSummary(output);
+  }
+  if (firstLine.includes("[echo break") || firstLine.includes("[echo-break") || lower.includes("echo-1:")) {
+    return formatEchoGuardSummary(output);
+  }
+  if (lower.includes("[superseded near-duplicate plan removed")) {
+    return formatSupersededPlanSummary();
+  }
+  return null;
+}
 function stripTrustTierWrapperForTui(text2, maxWrapperChars = 400) {
   const trustWrapper = new RegExp(
     `^\\[trust_tier:[^\\]\\n]{0,${Math.max(0, maxWrapperChars)}}\\][ \\t]*(?:\\n)?`,
@@ -634018,6 +635038,14 @@ function resolveToolOutputMaxLines(verbose) {
 }
 function buildToolResultBody(toolName, success, output, verbose) {
   const debug = loadConfig()?.debug ?? false;
+  const internalControlSummary = summarizeInternalControlOutput(output);
+  if (internalControlSummary && internalControlSummary.length > 0) {
+    return internalControlSummary.map((line) => ({
+      text: line,
+      mode: "wrap",
+      kind: "plain"
+    }));
+  }
   if (toolName === "file_edit" || toolName === "file_patch") {
     if (!success) {
       return [
@@ -636220,14 +637248,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);
@@ -636598,7 +637626,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) {
@@ -636613,7 +637641,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";
@@ -639253,7 +640281,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;
@@ -639497,7 +640525,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);
@@ -639512,7 +640540,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"() {
@@ -639528,7 +640556,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");
@@ -640894,7 +641922,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;
@@ -641392,7 +642420,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);
@@ -668986,7 +670014,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,
@@ -682346,7 +683374,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}` };
   }
@@ -688972,6 +690000,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 = "";
@@ -688983,6 +690023,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();
@@ -689071,6 +690113,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() {
@@ -689111,6 +690181,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;
         }
@@ -689180,6 +690253,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;
@@ -689190,6 +690271,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);
@@ -689198,12 +690280,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);
@@ -689216,12 +690299,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);
@@ -689245,6 +690330,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);
@@ -689254,10 +690340,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) {
@@ -696814,7 +697902,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";
 }
@@ -696822,7 +697910,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) {
@@ -696933,7 +698021,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;
@@ -697338,7 +698426,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,
@@ -697650,12 +698738,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();
@@ -698468,7 +699556,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}`;
@@ -698501,7 +699589,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;
@@ -699561,7 +700649,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"];
@@ -700501,11 +701589,29 @@ function isTelegramNoReplySentinel(text2) {
   const lower = compactTelegramVisibleText(text2).toLowerCase();
   return lower === "no_reply" || lower.startsWith("no_reply");
 }
+function isTelegramInternalControlText(text2) {
+  const compact4 = compactTelegramVisibleText(text2);
+  if (!compact4) return false;
+  const lower = compact4.toLowerCase();
+  const patterns = [
+    /\[superseded near-duplicate plan removed/i,
+    /\[echo break/i,
+    /\[branch-extract\b/i,
+    /\[discovery contract\]/i,
+    /\[curated segments\]/i,
+    /\[branch-duplicate-blocked\]/i,
+    /branch-extract preempted/i,
+    /contract: use these anchors as evidence/i,
+    /\becho break\b/i
+  ];
+  return patterns.some((pattern) => pattern.test(lower));
+}
 function isTelegramInternalStatusText(text2) {
   const compact4 = compactTelegramVisibleText(text2);
   if (!compact4) return false;
   const lower = compact4.toLowerCase();
   if (isTelegramNoReplySentinel(compact4)) return true;
+  if (isTelegramInternalControlText(compact4)) return true;
   if (lower === "complete" || lower === "completed") return true;
   if (/^memory stage:/i.test(compact4)) return true;
   if (/^\[ppr[-_\s]?skip\]/i.test(compact4)) return true;
@@ -700560,6 +701666,7 @@ function cleanTelegramVisibleReply(text2, options2 = {}) {
   if (!clean5) return "";
   if (options2.suppressPotentialNoReplyPrefix && isTelegramPotentialNoReplyPrefix(clean5))
     return "";
+  if (isTelegramInternalControlText(clean5)) return "";
   if (isTelegramInternalStatusText(clean5)) return "";
   const filtered = stripTelegramStuckSelfTalk(clean5).trim();
   if (!filtered) return "";
@@ -700806,7 +701913,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;
@@ -700846,6 +701953,7 @@ function formatTelegramProgressEvent(event) {
   }
   if (event.type === "tool_result") {
     const preview = sanitizeTelegramProgressText(event.content || "", 1500);
+    if (isTelegramInternalControlText(preview)) return null;
     if (isTelegramInternalStatusText(preview)) return null;
     return toolResultBlock(
       event.toolName || "tool",
@@ -700981,6 +702089,7 @@ function applyTelegramAdminLivePanelEvent(state, event) {
   }
   if (event.type === "tool_result" && event.toolName && event.toolName !== "task_complete") {
     const preview = sanitizeTelegramProgressText(event.content || "", 260);
+    if (isTelegramInternalControlText(preview)) return;
     const line = `${event.success ? "✓" : "✗"} ${event.toolName}${preview ? `: ${preview}` : ""}`;
     if (TELEGRAM_ADMIN_LIVE_MUTATION_TOOLS.has(event.toolName)) {
       pushTelegramAdminPanelMutationLine(state, line);
@@ -702970,7 +704079,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, "-")}`;
@@ -705042,11 +706151,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() {
@@ -705279,7 +706388,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",
@@ -705298,7 +706407,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) : [],
@@ -705755,7 +706864,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);
@@ -706945,7 +708054,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)) {
@@ -707108,7 +708217,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: [],
@@ -707193,7 +708302,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: [],
@@ -709957,7 +711066,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) {
@@ -720652,14 +721761,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));
@@ -720950,7 +722059,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",
@@ -721013,7 +722122,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) {
@@ -740424,7 +741533,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 {
@@ -748593,7 +749702,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;
@@ -748731,8 +749840,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 {
     }
@@ -750969,7 +752078,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,
@@ -751903,7 +753012,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, "");
@@ -752065,6 +753174,11 @@ function writeSubAgentEventForView(statusBar, agentId, event, verbose = false) {
   }
 }
 function formatSubAgentEventForView(event) {
+  const summarizeEventContent = (content) => {
+    const summaryLines = summarizeInternalControlOutput(content);
+    if (!summaryLines || summaryLines.length === 0) return null;
+    return truncateSubAgentViewText(summaryLines.join("\n"), 420);
+  };
   switch (event.type) {
     case "tool_call": {
       let args = "";
@@ -752077,17 +753191,26 @@ function formatSubAgentEventForView(event) {
     }
     case "tool_result": {
       const mark = event.success === false ? "✗" : "✓";
-      const body = (event.content ?? "").split("\n").slice(0, 3).join(" ").trim();
+      const output = event.content ?? "";
+      const summary = summarizeEventContent(output);
+      const body = summary ? `${summary}` : output.split("\n").slice(0, 3).join(" ").trim();
+      if (summary) {
+        const compact4 = `${mark} ${event.toolName ?? "tool"}
+${summary}`;
+        return truncateSubAgentViewText(compact4, 420);
+      }
       return `${mark} ${event.toolName ?? "tool"}${body ? `: ${truncateSubAgentViewText(body, 300)}` : ""}`;
     }
     case "assistant_text":
     case "model_response": {
-      const t2 = (event.content ?? "").trim();
+      const summary = summarizeEventContent(event.content ?? "");
+      const t2 = summary ?? (event.content ?? "").trim();
       return t2 ? truncateSubAgentViewText(t2, 1e3) : null;
     }
     case "status": {
-      const t2 = (event.content ?? "").trim();
-      return t2 ? `· ${truncateSubAgentViewText(t2, 300)}` : null;
+      const summary = summarizeEventContent(event.content ?? "");
+      const t2 = summary ?? (event.content ?? "").trim();
+      return t2 ? `· ${truncateSubAgentViewText(t2, 420)}` : null;
     }
     case "trajectory_checkpoint": {
       const assessment = event.trajectory?.assessment ?? "updated";
@@ -754648,12 +755771,14 @@ ${entry.fullContent}`
           break;
         }
         const statusContent = event.content ?? "";
+        const compactStatusLines = summarizeInternalControlOutput(statusContent);
+        const compactStatusContent = compactStatusLines?.length ? compactStatusLines.join("\n") : statusContent;
         const gpuWaitingStatus = /^Waiting for free GPU\.{3,}$/.test(
-          statusContent
+          compactStatusContent
         );
-        const gpuResumeStatus = statusContent === "GPU Free, Resuming";
+        const gpuResumeStatus = compactStatusContent === "GPU Free, Resuming";
         if (gpuWaitingStatus) {
-          const dotCount = statusContent.match(/\.+$/)?.[0]?.length ?? 3;
+          const dotCount = compactStatusContent.match(/\.+$/)?.[0]?.length ?? 3;
           if (startGpuRecoveryBlock(dotCount)) break;
         } else if (gpuResumeStatus && finishGpuRecoveryBlock()) {
           break;
@@ -754662,13 +755787,13 @@ ${entry.fullContent}`
         if (!config.debug && !gpuRecoveryStatus) break;
         if (isNeovimActive()) {
           writeToNeovimOutput(
-            `\x1B[38;5;250m${event.content ?? ""}\x1B[0m\r
+            `\x1B[38;5;250m${compactStatusContent}\x1B[0m\r
 `
           );
         } else {
-          contentWrite(() => renderInfo(event.content ?? ""));
-          if (event.content && event.content.startsWith("Provenance saved: ")) {
-            lastProvenancePath = event.content.slice("Provenance saved: ".length).trim();
+          contentWrite(() => renderInfo(compactStatusContent));
+          if (statusContent && statusContent.startsWith("Provenance saved: ")) {
+            lastProvenancePath = statusContent.slice("Provenance saved: ".length).trim();
           }
         }
         break;
@@ -757008,6 +758133,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);
@@ -761224,13 +762355,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,