omnius 1.0.343 → 1.0.345

package/dist/index.js

@@ -187,8 +187,8 @@ function printInfo(message2) {
   process.stdout.write(`${c.cyan("i")} ${message2}
 `);
 }
-function printKeyValue(key, value2, indent = 0) {
-  const pad = " ".repeat(indent);
+function printKeyValue(key, value2, indent2 = 0) {
+  const pad = " ".repeat(indent2);
   process.stdout.write(`${pad}${c.dim(key + ":")} ${value2}
 `);
 }
@@ -14652,12 +14652,12 @@ function chooseRetrievalWeights(input) {
   let vectorWeight = input.vectorWeight;
   let graphWeight = input.graphWeight;
   if (lexicalWeight === void 0 && vectorWeight === void 0 && graphWeight === void 0) {
-    const queryTerms = terms(input.query).size;
-    if (queryTerms <= 2) {
+    const queryTerms2 = terms(input.query).size;
+    if (queryTerms2 <= 2) {
       lexicalWeight = 0.55;
       vectorWeight = 0.3;
       graphWeight = 0.15;
-    } else if (queryTerms >= 6) {
+    } else if (queryTerms2 >= 6) {
       lexicalWeight = 0.3;
       vectorWeight = 0.55;
       graphWeight = 0.15;
@@ -16993,9 +16993,9 @@ var init_episodeStore = __esm({
           if (query.query) {
             const queryLower = query.query.toLowerCase();
             const contentLower = ep.content.toLowerCase();
-            const queryTerms = queryLower.split(/\s+/).filter((t2) => t2.length > 2);
-            const matched = queryTerms.filter((t2) => contentLower.includes(t2)).length;
-            lex = queryTerms.length > 0 ? matched / queryTerms.length : 0;
+            const queryTerms2 = queryLower.split(/\s+/).filter((t2) => t2.length > 2);
+            const matched = queryTerms2.filter((t2) => contentLower.includes(t2)).length;
+            lex = queryTerms2.length > 0 ? matched / queryTerms2.length : 0;
           }
           let emb = 0;
           if (qEmb && ep.embedding && ep.embedding.length === qEmb.length) {
@@ -23939,9 +23939,9 @@ import { resolve as resolve13, join as join23, basename as basename2 } from "nod
 import { existsSync as existsSync23 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 function termMatchScore(query, document2) {
-  const queryTerms = tokenize2(query);
+  const queryTerms2 = tokenize2(query);
   const docTerms = tokenize2(document2);
-  if (queryTerms.length === 0 || docTerms.length === 0)
+  if (queryTerms2.length === 0 || docTerms.length === 0)
     return 0;
   const docSet = new Set(docTerms);
   const docBigrams = /* @__PURE__ */ new Set();
@@ -23951,7 +23951,7 @@ function termMatchScore(query, document2) {
   let matchedTerms = 0;
   let matchedBigrams = 0;
   let totalWeight = 0;
-  for (const term of queryTerms) {
+  for (const term of queryTerms2) {
     totalWeight += 1;
     if (docSet.has(term)) {
       matchedTerms += 1;
@@ -23959,8 +23959,8 @@ function termMatchScore(query, document2) {
       matchedTerms += 0.5;
     }
   }
-  for (let i2 = 0; i2 < queryTerms.length - 1; i2++) {
-    const bigram = `${queryTerms[i2]} ${queryTerms[i2 + 1]}`;
+  for (let i2 = 0; i2 < queryTerms2.length - 1; i2++) {
+    const bigram = `${queryTerms2[i2]} ${queryTerms2[i2 + 1]}`;
     totalWeight += 1;
     if (docBigrams.has(bigram)) {
       matchedBigrams += 1;
@@ -26395,7 +26395,7 @@ var init_codebase_map = __esm({
         if (depth > maxDepth)
           return "";
         const lines = [];
-        const indent = "  ".repeat(depth);
+        const indent2 = "  ".repeat(depth);
         try {
           const entries = readdirSync10(dir, { withFileTypes: true }).filter((e2) => !e2.name.startsWith(".") || e2.name === ".github").sort((a2, b) => {
             if (a2.isDirectory() && !b.isDirectory())
@@ -26409,20 +26409,20 @@ var init_codebase_map = __esm({
           for (const d2 of dirs) {
             const subPath = join28(dir, d2.name);
             const fileCount = this.countFilesShallow(subPath);
-            lines.push(`${indent}${d2.name}/ (${fileCount} files)`);
+            lines.push(`${indent2}${d2.name}/ (${fileCount} files)`);
             const subtree = this.buildTree(subPath, rootDir, depth + 1, maxDepth, showFiles);
             if (subtree)
               lines.push(subtree);
           }
           if (showFiles) {
             for (const f2 of files.slice(0, 20)) {
-              lines.push(`${indent}${f2.name}`);
+              lines.push(`${indent2}${f2.name}`);
             }
             if (files.length > 20) {
-              lines.push(`${indent}... ${files.length - 20} more files`);
+              lines.push(`${indent2}... ${files.length - 20} more files`);
             }
           } else if (depth === 0 && files.length > 0) {
-            lines.push(`${indent}(${files.length} root files)`);
+            lines.push(`${indent2}(${files.length} root files)`);
           }
         } catch {
         }
@@ -57725,21 +57725,21 @@ var init_src21 = __esm({
 });
 
 // ../node_modules/@libp2p/logger/dist/src/index.js
-function formatError(v, indent = "") {
+function formatError(v, indent2 = "") {
   const message2 = notEmpty(v.message);
   const stack = notEmpty(v.stack);
   if (message2 != null && stack != null) {
     if (stack.includes(message2)) {
       return `${stack.split("\n").join(`
-${indent}`)}`;
+${indent2}`)}`;
     }
     return `${message2}
-${indent}${stack.split("\n").join(`
-${indent}`)}`;
+${indent2}${stack.split("\n").join(`
+${indent2}`)}`;
   }
   if (stack != null) {
     return `${stack.split("\n").join(`
-${indent}`)}`;
+${indent2}`)}`;
   }
   if (message2 != null) {
     return `${message2}`;
@@ -57749,21 +57749,21 @@ ${indent}`)}`;
 function isAggregateError(err) {
   return err instanceof AggregateError || err?.name === "AggregateError" && Array.isArray(err.errors);
 }
-function printError2(err, indent = "") {
+function printError2(err, indent2 = "") {
   if (isAggregateError(err)) {
-    let output = formatError(err, indent);
+    let output = formatError(err, indent2);
     if (err.errors.length > 0) {
-      indent = `${indent}    `;
+      indent2 = `${indent2}    `;
       output += `
-${indent}${err.errors.map((err2) => `${printError2(err2, `${indent}`)}`).join(`
-${indent}`)}`;
+${indent2}${err.errors.map((err2) => `${printError2(err2, `${indent2}`)}`).join(`
+${indent2}`)}`;
     } else {
       output += `
-${indent}[Error list was empty]`;
+${indent2}[Error list was empty]`;
     }
     return output.trim();
   }
-  return formatError(err, indent);
+  return formatError(err, indent2);
 }
 function createDisabledLogger(namespace2) {
   const logger2 = () => {
@@ -93897,8 +93897,8 @@ var require_error_helpers = __commonJS({
       const argName = params.split(",")[idx].trim();
       return `"${argName}" at position #${idx}`;
     }
-    function composeErrorMessage(msg, e2, indent = "    ") {
-      return [msg, ...e2.message.split("\n").map((l2) => indent + l2)].join("\n");
+    function composeErrorMessage(msg, e2, indent2 = "    ") {
+      return [msg, ...e2.message.split("\n").map((l2) => indent2 + l2)].join("\n");
     }
     function formatErrorCtor(ctor, paramIdx, error) {
       const [, params = null] = ctor.toString().match(/constructor\(([\w, ]+)\)/) || [];
@@ -119099,11 +119099,11 @@ var require_asn1 = __commonJS({
       if (level > 0) {
         rval += "\n";
       }
-      var indent = "";
+      var indent2 = "";
       for (var i2 = 0; i2 < level * indentation; ++i2) {
-        indent += " ";
+        indent2 += " ";
       }
-      rval += indent + "Tag: ";
+      rval += indent2 + "Tag: ";
       switch (obj.tagClass) {
         case asn1.Class.UNIVERSAL:
           rval += "Universal:";
@@ -119189,7 +119189,7 @@ var require_asn1 = __commonJS({
         rval += obj.type;
       }
       rval += "\n";
-      rval += indent + "Constructed: " + obj.constructed + "\n";
+      rval += indent2 + "Constructed: " + obj.constructed + "\n";
       if (obj.composed) {
         var subvalues = 0;
         var sub2 = "";
@@ -119202,9 +119202,9 @@ var require_asn1 = __commonJS({
             }
           }
         }
-        rval += indent + "Sub values: " + subvalues + sub2;
+        rval += indent2 + "Sub values: " + subvalues + sub2;
       } else {
-        rval += indent + "Value: ";
+        rval += indent2 + "Value: ";
         if (obj.type === asn1.Type.OID) {
           var oid = asn1.derToOid(obj.value);
           rval += oid;
@@ -434334,7 +434334,7 @@ ${lanes.join("\n")}
       var resetEscapeSequence = "\x1B[0m";
       var ellipsis = "...";
       var halfIndent = "  ";
-      var indent = "    ";
+      var indent2 = "    ";
       function getCategoryFormat(category) {
         switch (category) {
           case 1:
@@ -434436,10 +434436,10 @@ ${lanes.join("\n")}
               if (file) {
                 output += host.getNewLine();
                 output += halfIndent + formatLocation(file, start2, host);
-                output += formatCodeSpan(file, start2, length22, indent, "\x1B[96m", host);
+                output += formatCodeSpan(file, start2, length22, indent2, "\x1B[96m", host);
               }
               output += host.getNewLine();
-              output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine());
+              output += indent2 + flattenDiagnosticMessageText(messageText, host.getNewLine());
             }
           }
           output += host.getNewLine();
@@ -447189,11 +447189,11 @@ ${lanes.join("\n")}
         return `${d2.getHours().toString().padStart(2, "0")}:${d2.getMinutes().toString().padStart(2, "0")}:${d2.getSeconds().toString().padStart(2, "0")}.${d2.getMilliseconds().toString().padStart(3, "0")}`;
       }
       var indentStr = "\n    ";
-      function indent2(str) {
+      function indent22(str) {
         return indentStr + str.replace(/\n/g, indentStr);
       }
       function stringifyIndented(json) {
-        return indent2(JSON.stringify(json, void 0, 2));
+        return indent22(JSON.stringify(json, void 0, 2));
       }
       function isTypingUpToDate(cachedTyping, availableTypingVersions) {
         const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest"));
@@ -496948,7 +496948,7 @@ ${options2.prefix}` : "\n" : options2.prefix
         getLocationInNewDocument: () => getLocationInNewDocument,
         hasArgument: () => hasArgument,
         hasNoTypeScriptSource: () => hasNoTypeScriptSource,
-        indent: () => indent2,
+        indent: () => indent22,
         isBackgroundProject: () => isBackgroundProject,
         isConfigFile: () => isConfigFile,
         isConfiguredProject: () => isConfiguredProject,
@@ -506521,9 +506521,9 @@ ${json}${newLine}`;
         logErrorWorker(err, cmd, fileRequest) {
           let msg = "Exception on executing command " + cmd;
           if (err.message) {
-            msg += ":\n" + indent2(err.message);
+            msg += ":\n" + indent22(err.message);
             if (err.stack) {
-              msg += "\n" + indent2(err.stack);
+              msg += "\n" + indent22(err.stack);
             }
           }
           if (this.logger.hasLevel(
@@ -506538,7 +506538,7 @@ ${json}${newLine}`;
                   const text2 = getSnapshotText(scriptInfo.getSnapshot());
                   msg += `
 
-File text of ${fileRequest.file}:${indent2(text2)}
+File text of ${fileRequest.file}:${indent22(text2)}
 `;
                 }
               } catch {
@@ -508536,7 +508536,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
               3
               /* verbose */
             )) {
-              this.logger.info(`request:${indent2(this.toStringMessage(message2))}`);
+              this.logger.info(`request:${indent22(this.toStringMessage(message2))}`);
             }
           }
           let request;
@@ -509704,7 +509704,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
         getLocationInNewDocument: () => getLocationInNewDocument,
         hasArgument: () => hasArgument,
         hasNoTypeScriptSource: () => hasNoTypeScriptSource,
-        indent: () => indent2,
+        indent: () => indent22,
         isBackgroundProject: () => isBackgroundProject,
         isConfigFile: () => isConfigFile,
         isConfiguredProject: () => isConfiguredProject,
@@ -567057,6 +567057,609 @@ context_fabric: included=${included.length} dropped=${dropped.length} truncated=
   }
 });
 
+// packages/orchestrator/dist/evidenceLedger.js
+function buildExtract(content) {
+  const lines = content.split("\n");
+  if (lines.length <= SMALL_LINES && content.length <= SMALL_CHARS) {
+    return { text: content, fidelity: "full" };
+  }
+  const head = lines.slice(0, EXTRACT_HEAD);
+  const tail = lines.slice(-EXTRACT_TAIL);
+  const signatures = [];
+  for (let i2 = EXTRACT_HEAD; i2 < lines.length - EXTRACT_TAIL; i2++) {
+    const ln = lines[i2];
+    if (SIGNATURE_RE.test(ln))
+      signatures.push(`  ${i2 + 1}: ${ln.trim().slice(0, 120)}`);
+    if (signatures.length >= 30)
+      break;
+  }
+  const parts = [
+    head.join("\n"),
+    signatures.length ? `  … (${lines.length - EXTRACT_HEAD - EXTRACT_TAIL} lines elided; signatures:)
+${signatures.join("\n")}` : `  … (${lines.length - EXTRACT_HEAD - EXTRACT_TAIL} lines elided) …`,
+    tail.join("\n")
+  ];
+  return { text: parts.join("\n"), fidelity: "extract" };
+}
+function mergeRanges(ranges) {
+  if (ranges.length <= 1)
+    return ranges;
+  const sorted = [...ranges].sort((a2, b) => a2.start - b.start);
+  const out = [sorted[0]];
+  for (let i2 = 1; i2 < sorted.length; i2++) {
+    const r2 = sorted[i2];
+    const last2 = out[out.length - 1];
+    if (r2.start <= last2.end + 1)
+      last2.end = Math.max(last2.end, r2.end);
+    else
+      out.push({ ...r2 });
+  }
+  return out;
+}
+function rangeLabel(ranges) {
+  return ranges.map((r2) => r2.end === Infinity || r2.start === 0 ? "whole file" : `lines ${r2.start}-${r2.end}`).join(", ");
+}
+function indent(text2) {
+  return text2.split("\n").map((l2) => `    ${l2}`).join("\n");
+}
+var SMALL_LINES, SMALL_CHARS, EXTRACT_HEAD, EXTRACT_TAIL, SIGNATURE_RE, EvidenceLedger;
+var init_evidenceLedger = __esm({
+  "packages/orchestrator/dist/evidenceLedger.js"() {
+    "use strict";
+    SMALL_LINES = 60;
+    SMALL_CHARS = 2048;
+    EXTRACT_HEAD = 20;
+    EXTRACT_TAIL = 8;
+    SIGNATURE_RE = /^\s*(export\s+)?(async\s+)?(function|class|interface|type|const|def|public|private|protected|fn|impl|struct|enum|module|package|import|from|#include|CREATE\s+TABLE)\b/i;
+    EvidenceLedger = class {
+      entries = /* @__PURE__ */ new Map();
+      /** Record a successful read. `fileVersion` is the file's current writeCount. */
+      recordRead(input) {
+        const { path: path12, content, range, fileVersion, turn } = input;
+        if (!path12 || !content)
+          return;
+        const built = buildExtract(content);
+        const existing = this.entries.get(path12);
+        if (existing && existing.readVersion === fileVersion && !existing.stale) {
+          const keepNew = built.text.length >= existing.content.length;
+          this.entries.set(path12, {
+            ...existing,
+            content: keepNew ? built.text : existing.content,
+            fidelity: keepNew ? built.fidelity : existing.fidelity,
+            ranges: mergeRanges([...existing.ranges, range]),
+            lastReadTurn: turn,
+            stale: false
+          });
+          return;
+        }
+        this.entries.set(path12, {
+          path: path12,
+          readVersion: fileVersion,
+          lastReadTurn: turn,
+          ranges: [range],
+          content: built.text,
+          fidelity: built.fidelity,
+          stale: false
+        });
+      }
+      /** Mark a file's evidence stale because it was mutated to `newVersion`. */
+      markMutated(path12, newVersion, _turn) {
+        const e2 = this.entries.get(path12);
+        if (!e2)
+          return;
+        if (newVersion > e2.readVersion)
+          e2.stale = true;
+      }
+      /** Is there fresh (non-stale) evidence covering this read? */
+      hasFresh(path12) {
+        const e2 = this.entries.get(path12);
+        return !!e2 && !e2.stale;
+      }
+      get(path12) {
+        return this.entries.get(path12);
+      }
+      size() {
+        return this.entries.size;
+      }
+      clear() {
+        this.entries.clear();
+      }
+      /**
+       * Render the evidence block for the ACTIVE CONTEXT FRAME. Freshest reads
+       * first; stale entries are flagged (and kept short — they only need to say
+       * "re-read me"). Bounded to `maxChars`; ContextFrameBuilder budgets again.
+       */
+      renderBlock(maxChars = 6e3) {
+        if (this.entries.size === 0)
+          return null;
+        const sorted = [...this.entries.values()].sort((a2, b) => b.lastReadTurn - a2.lastReadTurn);
+        const lines = [
+          "Evidence already gathered this run — you ALREADY have the content below.",
+          "Do NOT re-read a FRESH file; use this. Re-read ONLY entries marked STALE.",
+          ""
+        ];
+        let used = lines.join("\n").length;
+        for (const e2 of sorted) {
+          const header = e2.stale ? `▸ ${e2.path} @v${e2.readVersion} [STALE — changed since read; re-read needed] (${rangeLabel(e2.ranges)})` : `▸ ${e2.path} @v${e2.readVersion} [FRESH] (${rangeLabel(e2.ranges)}):`;
+          const body = e2.stale ? "" : "\n" + indent(e2.content);
+          const chunk = `${header}${body}
+`;
+          if (used + chunk.length > maxChars) {
+            const stub = `▸ ${e2.path} @v${e2.readVersion} [${e2.stale ? "STALE" : "FRESH"}] (${rangeLabel(e2.ranges)})
+`;
+            if (used + stub.length <= maxChars) {
+              lines.push(stub);
+              used += stub.length;
+            }
+            continue;
+          }
+          lines.push(chunk);
+          used += chunk.length;
+        }
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/adversaryStream.js
+function adversarySystemPrompt() {
+  return [
+    "You are the ADVERSARY: a skeptical auditor running adjacent to a coding agent.",
+    "Your sole job is to instill doubt and DEMAND evidence. You never approve work to be polite.",
+    "The agent has a documented optimism bias — it claims completeness before proving it.",
+    "",
+    "Treat every claim as UNPROVEN until an INDEPENDENT check confirms it. Specifically:",
+    "  • started ≠ running — a PID or a log line is not a liveness probe.",
+    "  • exit code 0 / 'build complete' ≠ success — the specific artifact must exist.",
+    "  • an edit ≠ a fix — the failing command must be re-run and pass.",
+    "  • simulation / mock / placeholder ≠ real.",
+    "  • partial progress ≠ done.",
+    "Mixed results are the norm: do NOT let one success excuse an unproven completion claim.",
+    "",
+    "Given the agent's latest message and recent tool outcomes, decide whether the claim is proven.",
+    "Respond with ONLY a JSON object, no prose, no code fences:",
+    '{"class":"false_success|unproven_claim|weak_evidence|false_failure|ok",',
+    ' "shortText":"<=12 word headline",',
+    ' "confidence":0.0-1.0,  // how strongly the claim is NOT proven',
+    ' "details":"2-4 sentence skeptical critique citing the specific gap",',
+    ' "demand":"the ONE concrete independent check the agent must run next"}',
+    "",
+    'Use class "ok" ONLY when the recent tool evidence genuinely and independently proves the claim.',
+    "Be specific: name the file, command, or symbol whose verification is missing."
+  ].join("\n");
+}
+function buildObservationPrompt(obs, recentLedger) {
+  const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => `  - ${o2.tool}: ${o2.succeeded ? "OK" : "FAIL"} — ${o2.preview.slice(0, 120)}`).join("\n");
+  const priorDoubts = recentLedger.slice(-3).filter((e2) => e2.verdict !== "ok").map((e2) => `  - turn ${e2.turn}: ${e2.verdict} — demanded: ${e2.demand}`).join("\n");
+  return [
+    obs.claimsCompletion ? "The agent is asserting COMPLETION this turn." : "The agent produced a progress/success-flavored claim this turn.",
+    "",
+    "Agent's latest message:",
+    obs.assistantText.slice(0, 1800) || "(empty)",
+    "",
+    "Recent tool outcomes (evidence available):",
+    outcomes || "  (none)",
+    priorDoubts ? `
+Unresolved doubts you raised earlier:
+${priorDoubts}` : "",
+    "",
+    "Audit this. Return ONLY the JSON object."
+  ].join("\n");
+}
+function parseAdversaryCritique(raw) {
+  if (!raw)
+    return null;
+  let text2 = raw.trim().replace(/^```(?:json)?/i, "").replace(/```$/i, "").trim();
+  const start2 = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
+  if (start2 < 0 || end <= start2)
+    return null;
+  let obj;
+  try {
+    obj = JSON.parse(text2.slice(start2, end + 1));
+  } catch {
+    return null;
+  }
+  const cls = String(obj["class"] ?? "").toLowerCase();
+  const valid = [
+    "false_success",
+    "unproven_claim",
+    "weak_evidence",
+    "false_failure",
+    "ok"
+  ];
+  const klass = valid.includes(cls) ? cls : "unproven_claim";
+  let confidence2 = Number(obj["confidence"]);
+  if (!Number.isFinite(confidence2))
+    confidence2 = klass === "ok" ? 0.1 : 0.7;
+  confidence2 = Math.min(1, Math.max(0, confidence2));
+  return {
+    class: klass,
+    shortText: String(obj["shortText"] ?? obj["short_text"] ?? "claim unproven").slice(0, 120),
+    confidence: confidence2,
+    details: String(obj["details"] ?? "").slice(0, 1200),
+    demand: String(obj["demand"] ?? "").slice(0, 400)
+  };
+}
+var SUCCESS_LANGUAGE, AdversaryStream;
+var init_adversaryStream = __esm({
+  "packages/orchestrator/dist/adversaryStream.js"() {
+    "use strict";
+    SUCCESS_LANGUAGE = /\b(done|fixed|complete|completed|works|working|verified|validated|passed|all set|successfully|ready|live|hydrated|confirmed)\b/i;
+    AdversaryStream = class {
+      backend;
+      onCritique;
+      persistPath;
+      minConfidence;
+      timeoutMs;
+      ledger = [];
+      pending = null;
+      lastAuditedSignature = "";
+      inFlight = false;
+      constructor(opts) {
+        this.backend = opts.backend;
+        this.onCritique = opts.onCritique;
+        this.persistPath = opts.persistPath ?? null;
+        this.minConfidence = opts.minConfidence ?? 0.5;
+        this.timeoutMs = opts.timeoutMs ?? 2e4;
+        this.load();
+      }
+      get ledgerSize() {
+        return this.ledger.length;
+      }
+      /**
+       * Decide whether this turn carries a high-signal claim worth auditing. Cheap
+       * + synchronous. Only completion assertions or explicit success language gate
+       * an inference call, keeping cost bounded.
+       */
+      shouldAudit(obs) {
+        if (obs.claimsCompletion)
+          return true;
+        return SUCCESS_LANGUAGE.test(obs.assistantText);
+      }
+      /** Ingest an observation. Replaces any prior un-audited pending observation. */
+      observe(obs) {
+        if (!this.shouldAudit(obs))
+          return;
+        const sig = `${obs.turn}:${obs.assistantText.slice(0, 200)}`;
+        if (sig === this.lastAuditedSignature)
+          return;
+        this.pending = obs;
+      }
+      /**
+       * Fire the adversary inference if there is a pending observation and no call
+       * in flight. Detached/non-blocking — resolves when (or if) a critique lands.
+       * Returns the critique for testing; callers in the loop ignore the promise.
+       */
+      async tick() {
+        if (this.inFlight || !this.pending)
+          return null;
+        const obs = this.pending;
+        this.pending = null;
+        this.lastAuditedSignature = `${obs.turn}:${obs.assistantText.slice(0, 200)}`;
+        this.inFlight = true;
+        try {
+          const resp = await this.backend.chatCompletion({
+            messages: [
+              { role: "system", content: adversarySystemPrompt() },
+              { role: "user", content: buildObservationPrompt(obs, this.ledger) }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 400,
+            timeoutMs: this.timeoutMs
+          });
+          const content = resp.choices?.[0]?.message?.content ?? "";
+          const critique2 = parseAdversaryCritique(content);
+          if (!critique2)
+            return null;
+          this.ledger.push({
+            ts: Date.now(),
+            turn: obs.turn,
+            claim: obs.assistantText.slice(0, 240),
+            verdict: critique2.class,
+            confidence: critique2.confidence,
+            demand: critique2.demand
+          });
+          if (this.ledger.length > 100)
+            this.ledger = this.ledger.slice(-100);
+          this.persist();
+          if (critique2.class !== "ok" && critique2.confidence >= this.minConfidence) {
+            this.onCritique(critique2, obs.turn);
+            return critique2;
+          }
+          return null;
+        } catch {
+          return null;
+        } finally {
+          this.inFlight = false;
+        }
+      }
+      /** Format a critique as the system-prompt injection the main loop receives. */
+      static formatInjection(c8) {
+        return [
+          `[ADVERSARY CRITIQUE — ${c8.class} · ${Math.round(c8.confidence * 100)}% unproven]`,
+          c8.details,
+          c8.demand ? `Required independent check before claiming this again: ${c8.demand}` : ""
+        ].filter(Boolean).join("\n");
+      }
+      load() {
+        if (!this.persistPath)
+          return;
+        try {
+          const { readFileSync: readFileSync134, existsSync: existsSync164 } = __require("node:fs");
+          if (existsSync164(this.persistPath)) {
+            const data = JSON.parse(readFileSync134(this.persistPath, "utf-8"));
+            if (Array.isArray(data?.ledger))
+              this.ledger = data.ledger.slice(-100);
+          }
+        } catch {
+        }
+      }
+      persist() {
+        if (!this.persistPath)
+          return;
+        try {
+          const { writeFileSync: writeFileSync91, mkdirSync: mkdirSync106, existsSync: existsSync164 } = __require("node:fs");
+          const { dirname: dirname54 } = __require("node:path");
+          const dir = dirname54(this.persistPath);
+          if (!existsSync164(dir))
+            mkdirSync106(dir, { recursive: true });
+          writeFileSync91(this.persistPath, JSON.stringify({ ledger: this.ledger }, null, 2));
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/evidenceBranch.js
+function queryTerms(query) {
+  return [
+    ...new Set(query.toLowerCase().replace(/[^a-z0-9_<>./-]+/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS2.has(w)))
+  ];
+}
+function selectWindows(lines, terms2) {
+  const matched = [];
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const lower = lines[i2].toLowerCase();
+    let score = 0;
+    for (const t2 of terms2)
+      if (lower.includes(t2))
+        score++;
+    if (score > 0)
+      matched.push({ idx: i2, score });
+  }
+  const intervals = [
+    { start: 0, end: Math.min(lines.length, HEAD_LINES2) - 1, score: 0.5 }
+  ];
+  matched.sort((a2, b) => b.score - a2.score).slice(0, 30).forEach((m2) => {
+    intervals.push({
+      start: Math.max(0, m2.idx - SNIPPET_CONTEXT),
+      end: Math.min(lines.length - 1, m2.idx + SNIPPET_CONTEXT),
+      score: m2.score
+    });
+  });
+  intervals.sort((a2, b) => a2.start - b.start);
+  const merged = [];
+  for (const iv of intervals) {
+    const last2 = merged[merged.length - 1];
+    if (last2 && iv.start <= last2.end + 1) {
+      last2.end = Math.max(last2.end, iv.end);
+      last2.score = Math.max(last2.score, iv.score);
+    } else
+      merged.push({ ...iv });
+  }
+  let budget = MAX_SNIPPET_LINES;
+  const head = merged.find((m2) => m2.start === 0);
+  const rest = merged.filter((m2) => m2 !== head).sort((a2, b) => b.score - a2.score);
+  const kept = (head ? [head] : []).concat(rest);
+  const chosen = [];
+  for (const m2 of kept) {
+    const len = m2.end - m2.start + 1;
+    if (budget - len < 0)
+      continue;
+    budget -= len;
+    chosen.push(m2);
+  }
+  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"),
+    score: m2.score
+  }));
+}
+function extractionPrompt(query, path12, windows) {
+  const blocks = windows.map((w) => `--- ${path12} lines ${w.start}-${w.end} ---
+${w.text}`).join("\n\n");
+  return [
+    `You are an extraction worker in a throwaway context. Extract ONLY what answers the query; do not summarize the whole file.`,
+    `Query: ${query}`,
+    ``,
+    `File excerpts:`,
+    blocks,
+    ``,
+    `Respond with ONLY a JSON object, no prose, no fences:`,
+    `{"claim":"the specific facts that answer the query, quoting exact values",`,
+    ` "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`,
+    ` "found":true|false}`
+  ].join("\n");
+}
+function parseExtraction(raw) {
+  if (!raw)
+    return null;
+  const s2 = raw.indexOf("{");
+  const e2 = raw.lastIndexOf("}");
+  if (s2 < 0 || e2 <= s2)
+    return null;
+  let o2;
+  try {
+    o2 = JSON.parse(raw.slice(s2, e2 + 1));
+  } catch {
+    return null;
+  }
+  const num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+  let conf = Number(o2["confidence"]);
+  if (!Number.isFinite(conf))
+    conf = 0.5;
+  return {
+    claim: String(o2["claim"] ?? "").slice(0, 800),
+    sourceStart: num2(o2["source_start"]),
+    sourceEnd: num2(o2["source_end"]),
+    confidence: Math.min(1, Math.max(0, conf)),
+    found: o2["found"] !== false
+  };
+}
+async function extractEvidence(opts) {
+  const { path: path12, query, content, fileVersion, backend } = opts;
+  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 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)
+          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;
+      return {
+        path: path12,
+        query,
+        claim: claim2,
+        sourceStart: starts.length ? Math.min(...starts) : null,
+        sourceEnd: ends.length ? Math.max(...ends) : null,
+        fileVersion,
+        confidence: Math.min(1, covered / Math.max(1, terms2.length)),
+        exploredLines: lines.length,
+        injectedChars: claim2.length
+      };
+    }
+  }
+  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(query, path12, windows) }
+        ],
+        tools: [],
+        temperature: 0,
+        maxTokens: 900,
+        timeoutMs: opts.timeoutMs ?? 3e4
+      });
+      parsed = parseExtraction(resp.choices?.[0]?.message?.content ?? "");
+    } catch {
+      parsed = null;
+    }
+  }
+  const claim = parsed && parsed.found && parsed.claim ? parsed.claim : `No evidence for "${query}" found in the explored windows of ${path12}.`;
+  return {
+    path: path12,
+    query,
+    claim,
+    sourceStart: parsed?.sourceStart ?? null,
+    sourceEnd: parsed?.sourceEnd ?? null,
+    fileVersion,
+    confidence: parsed?.found ? parsed.confidence : 0.2,
+    exploredLines,
+    injectedChars: claim.length
+  };
+}
+function shouldBranchRead(contentLength, lineCount, hasExplicitSmallRange, thresholdChars = 8e3) {
+  if (hasExplicitSmallRange)
+    return false;
+  return contentLength > thresholdChars || lineCount > 200;
+}
+var WINDOW_LINES, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, STOPWORDS2;
+var init_evidenceBranch = __esm({
+  "packages/orchestrator/dist/evidenceBranch.js"() {
+    "use strict";
+    WINDOW_LINES = 40;
+    SNIPPET_CONTEXT = 4;
+    HEAD_LINES2 = 10;
+    MAX_SNIPPET_LINES = 220;
+    STOPWORDS2 = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "what",
+      "which",
+      "from",
+      "with",
+      "that",
+      "this",
+      "does",
+      "use",
+      "uses",
+      "line",
+      "file",
+      "value",
+      "values",
+      "set",
+      "sets",
+      "is",
+      "are",
+      "of",
+      "on",
+      "in",
+      "a",
+      "an",
+      "to",
+      "its",
+      "do",
+      "answer",
+      "report",
+      "tell"
+    ]);
+  }
+});
+
 // packages/orchestrator/dist/contextEngine.js
 function estimateTokens3(messages2) {
   const chars = messages2.reduce((sum, message2) => sum + message2.content.length + message2.role.length + (message2.name?.length ?? 0), 0);
@@ -568817,6 +569420,9 @@ var init_agenticRunner = __esm({
     init_modelProfile();
     init_failureHandoff();
     init_context_fabric();
+    init_evidenceLedger();
+    init_adversaryStream();
+    init_evidenceBranch();
     init_contextEngine();
     init_prompt_cache();
     TOOL_SUBSETS = {
@@ -569308,6 +569914,16 @@ var init_agenticRunner = __esm({
       // ledger and emitted as one bounded frame before each model call.
       _contextLedger = new ContextLedger();
       _contextFrameBuilder = new ContextFrameBuilder();
+      // Durable, version-aware record of what has ALREADY been read this run, with
+      // the actual content — rebuilt into the ACTIVE CONTEXT FRAME each turn so it
+      // survives compaction. The structural fix for the re-read loop: the model
+      // sees the evidence it already has instead of re-deriving it. See
+      // evidenceLedger.ts.
+      _evidenceLedger = new EvidenceLedger();
+      // Generative, inference-driven adversary running as an async memory stream
+      // adjacent to the main loop. Initialized per run when the step critic is
+      // enabled and a backend is available. See adversaryStream.ts.
+      _adversaryStream = null;
       _lastContextFrameDiagnostics = null;
       _lastContextPressureSnapshot = null;
       _lastActiveForgettingReport = null;
@@ -569966,6 +570582,91 @@ Your hypotheses MUST address this specific error, not generic causes.
           return null;
         }
       }
+      // ── Failing-approach detector (the "stop retrying variants" reflex) ───────
+      // Encodes the behavior an effective agent uses and the dropbear 27× loop
+      // lacked: when the SAME error recurs ~3× — especially while the same target
+      // is edited again and again — the error is telling you the CHANGE is wrong
+      // (an unsupported attribute, a wrong API/signature, a missing dep), not that
+      // you haven't found the right value yet. Stop, diagnose the root cause from
+      // the full error, verify the correct contract, then act — do NOT re-apply a
+      // variant. Distinct from REG-58/60 (no-write / slow-write): this fires while
+      // edits ARE landing but verification keeps failing the same way.
+      _failingApproachCooldownUntil = -1;
+      /**
+       * Most-common normalized failure signature in the recent window, or null if
+       * no signature recurs ≥3×. Normalization drops the VARYING tokens (quoted
+       * names, paths, numbers) so "unrecognized attribute: 'nstack'" and
+       * "...: 'narena'" collapse to one signature. Transient/network failures are
+       * excluded — retrying those is legitimate, not a failing approach.
+       */
+      _recurringFailureSignature(turn, window2 = 10) {
+        const recent = this._recentFailures.filter((f2) => turn - f2.turn <= window2);
+        if (recent.length < 3)
+          return null;
+        const TRANSIENT = /timed? ?out|timeout|econnreset|econnrefused|etimedout|rate.?limit|503|502|temporarily|try again|socket hang|network|fetch failed/i;
+        const norm = (s2) => s2.toLowerCase().replace(/['"`][^'"`]*['"`]/g, " ").replace(/\/[^\s:]+/g, " ").replace(/\d+/g, " ").replace(/\s+/g, " ").trim().slice(0, 80);
+        const groups = /* @__PURE__ */ new Map();
+        for (const f2 of recent) {
+          const raw = (f2.error || f2.output || "").slice(0, 200);
+          if (!raw || TRANSIENT.test(raw))
+            continue;
+          const sig = norm(raw);
+          if (!sig)
+            continue;
+          const g = groups.get(sig) ?? { count: 0, sample: raw };
+          g.count++;
+          groups.set(sig, g);
+        }
+        let best = null;
+        for (const [signature, g] of groups) {
+          if (!best || g.count > best.count)
+            best = { signature, count: g.count, sample: g.sample };
+        }
+        return best && best.count >= 3 ? best : null;
+      }
+      /**
+       * Detect a failing approach and return a decisive root-cause directive, or
+       * null. Fires when a non-transient error recurs ≥3× in the recent window
+       * (optionally corroborated by the error-cluster tracker), self-cooldown 8
+       * turns. OMNIUS_DISABLE_FAILING_APPROACH=1 disables.
+       */
+      _detectFailingApproach(turn) {
+        if (process.env["OMNIUS_DISABLE_FAILING_APPROACH"] === "1")
+          return null;
+        if (turn <= this._failingApproachCooldownUntil)
+          return null;
+        const recurring = this._recurringFailureSignature(turn);
+        if (!recurring)
+          return null;
+        let churnPath = null;
+        let churnWrites = 0;
+        const wf = this._worldFacts;
+        if (wf) {
+          for (const [p2, info] of wf.files) {
+            const writes = info.writeCount ?? 0;
+            const age = turn - (info.lastWriteTurn ?? -999);
+            if (writes >= 3 && age <= 8 && writes > churnWrites) {
+              churnWrites = writes;
+              churnPath = p2;
+            }
+          }
+        }
+        this._failingApproachCooldownUntil = turn + 8;
+        const target = churnPath ? `${churnPath} (edited ${churnWrites}× recently)` : "the same target";
+        return [
+          `[FAILING APPROACH DETECTED — stop retrying variants]`,
+          `The SAME error has recurred ${recurring.count}× in your recent attempts while you keep changing ${target}:`,
+          `  ${recurring.sample}`,
+          ``,
+          `Trying another variant of the same change is not converging. A repeating error means the CHANGE ITSELF is wrong — an unsupported attribute/option, a wrong API or signature, or a missing prerequisite — not that you haven't hit the right value yet.`,
+          `MANDATORY before your next edit:`,
+          `  1. Re-read the FULL error above and name the EXACT token it rejects (attribute / symbol / flag / path).`,
+          `  2. VERIFY the correct contract for that token from an authoritative source — read the defining file, the schema, or the API/docs. Do NOT guess.`,
+          `  3. State the root cause in one sentence: "<token> fails because <reason>."`,
+          `  4. Then make ONE change that step 2 supports. If the thing you want is genuinely unsupported, REMOVE it and choose a supported alternative — do not re-add a variant.`,
+          `Do NOT re-apply another variant of the rejected change.`
+        ].join("\n");
+      }
       /**
        * REG-61 sliding-window first-edit / sustained-edit nudge.
        *
@@ -572277,7 +572978,10 @@ ${latest.output || ""}`.trim();
           sections.push(`Last test outcome: ${wf.lastTest.passed ? "PASSED" : "FAILED"} (turn ${wf.lastTest.turn ?? "?"})`);
         }
         sections.push(`(turn ${turn} — this block is regenerated every turn from your tool history)`);
-        return sections.join("\n");
+        const evidenceBlock = process.env["OMNIUS_DISABLE_EVIDENCE_FRAME"] === "1" ? null : this._evidenceLedger.renderBlock(6e3);
+        return evidenceBlock ? `${evidenceBlock}
+
+${sections.join("\n")}` : sections.join("\n");
       }
       /**
        * REG-62: Pre-call knowledge injection. Builds a concise system message
@@ -572805,7 +573509,10 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
         this._contextLedger.upsertMany(signals.filter(Boolean));
         const frame = this._contextFrameBuilder.build(this._contextLedger.values(), {
           turn,
-          maxChars: 1e4,
+          // Raised from 10k to fit the durable read-evidence content (known_files)
+          // that replaces the re-read loop; the per-kind budget below caps it.
+          maxChars: 13e3,
+          kindCharBudget: { known_files: 6500 },
           includeDiagnostics: process.env["OMNIUS_CONTEXT_FABRIC_DIAGNOSTICS"] === "1"
         });
         this._lastContextFrameDiagnostics = frame.diagnostics;
@@ -573048,6 +573755,70 @@ ${blob}
         const canonical = this.lookupRegisteredTool(name10)?.name ?? name10;
         return `${canonical}:${this._buildExactArgsKey(args)}`;
       }
+      // ── REG-71: region-aware read dedup ────────────────────────────────────────
+      // The exact-args fingerprint treats file_read(offset=1,limit=5) and
+      // file_read(offset=1,limit=3) as DISTINCT calls, so the REG-69 cache never
+      // matches overlapping sub-region reads of the same file. Verified in the
+      // wild: one session re-read an unedited file 27× with nudged ranges
+      // (1-20, 1-5, 1-3, 1-2, 1-10…), every one a cache miss + real disk read.
+      // We coalesce a read whose [start,end] is a subset of an already-seen read
+      // of the same path onto that wider read's fingerprint, so the existing
+      // cache-serve + hit-counter + hard-block machinery catches the loop.
+      // Per path we keep up to 8 distinct covering intervals (disjoint regions of
+      // a large file stay independent). Explicit-range reads return exactly their
+      // range, so subset coverage is content-correct; a whole-file read only
+      // covers other whole-file reads (large files return a preview, not the
+      // full body, so it must not be claimed to cover an inner range).
+      _readCoverage = /* @__PURE__ */ new Map();
+      /** Extract (path, [start,end], whole) for a region-coalesceable read, else null. */
+      _readIntervalFromArgs(name10, args) {
+        const canonical = this.lookupRegisteredTool(name10)?.name ?? name10;
+        if (canonical !== "file_read")
+          return null;
+        const a2 = args ?? {};
+        const path12 = typeof a2["path"] === "string" && a2["path"] || typeof a2["file"] === "string" && a2["file"] || typeof a2["file_path"] === "string" && a2["file_path"] || "";
+        if (!path12)
+          return null;
+        const offset = typeof a2["offset"] === "number" ? a2["offset"] : void 0;
+        const limit = typeof a2["limit"] === "number" ? a2["limit"] : void 0;
+        const whole = offset === void 0 && limit === void 0;
+        const start2 = Math.max(1, offset ?? 1);
+        const end = whole ? Number.POSITIVE_INFINITY : limit !== void 0 ? start2 + Math.max(0, limit) - 1 : Number.POSITIVE_INFINITY;
+        return { key: `${canonical}|${path12}`, start: start2, end, whole };
+      }
+      /**
+       * Resolve the fingerprint to use for cache identity. For file_read whose
+       * region is already covered by a wider seen read of the same file, returns
+       * that read's fingerprint (so the repeat is recognized); otherwise returns
+       * the exact fingerprint unchanged.
+       */
+      _resolveReadCoverageFingerprint(name10, args, exactFingerprint) {
+        const iv = this._readIntervalFromArgs(name10, args);
+        if (!iv)
+          return exactFingerprint;
+        const intervals = this._readCoverage.get(iv.key);
+        if (!intervals)
+          return exactFingerprint;
+        for (const cov of intervals) {
+          const covered = iv.whole ? cov.whole : !cov.whole && cov.start <= iv.start && iv.end <= cov.end;
+          if (covered)
+            return cov.fingerprint;
+        }
+        return exactFingerprint;
+      }
+      /** Register a read's region under the fingerprint that cached its result. */
+      _registerReadCoverage(name10, args, fingerprint) {
+        const iv = this._readIntervalFromArgs(name10, args);
+        if (!iv)
+          return;
+        const list = this._readCoverage.get(iv.key) ?? [];
+        const pruned = list.filter((cov) => !(cov.whole === iv.whole && iv.start <= cov.start && cov.end <= iv.end && cov.fingerprint !== fingerprint));
+        if (!pruned.some((cov) => cov.fingerprint === fingerprint)) {
+          pruned.push({ start: iv.start, end: iv.end, whole: iv.whole, fingerprint });
+        }
+        pruned.sort((a2, b) => b.end - b.start - (a2.end - a2.start));
+        this._readCoverage.set(iv.key, pruned.slice(0, 8));
+      }
       _dedupeToolCallsForResponse(toolCalls, turn) {
         if (toolCalls.length <= 1)
           return toolCalls;
@@ -573910,6 +574681,7 @@ Respond with your assessment, then take action.`;
         this._contextTree = null;
         this._lastSurfacedAnchorIds.clear();
         this._contextLedger = new ContextLedger();
+        this._evidenceLedger = new EvidenceLedger();
         this._lastContextFrameDiagnostics = null;
         this._lastContextPressureSnapshot = null;
         this._lastActiveForgettingReport = null;
@@ -574412,6 +575184,35 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         this._selfConsistencyVotes = 0;
         this._retrievalContextCache = null;
         this._adversaryMode = this.options.adversaryMode ?? "both";
+        if (this.options.disableAdversaryCritic !== true && this.backend && typeof this.backend.chatCompletion === "function") {
+          const persistPath = this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius", "memory", "adversary-stream.json") : null;
+          this._adversaryStream = new AdversaryStream({
+            backend: this.backend,
+            persistPath,
+            onCritique: (critique2, sourceTurn) => {
+              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                this.pendingUserMessages.push(AdversaryStream.formatInjection(critique2));
+              }
+              this.emit({
+                type: "adversary_reaction",
+                adversary: {
+                  class: critique2.class === "false_failure" ? "false_failure" : critique2.class === "false_success" ? "false_success" : "guidance",
+                  shortText: critique2.shortText,
+                  confidence: critique2.confidence,
+                  details: AdversaryStream.formatInjection(critique2)
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              this.emit({
+                type: "status",
+                content: `Adversary (generative) flagged turn ${sourceTurn}: ${critique2.class} (${Math.round(critique2.confidence * 100)}%)`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          });
+        } else {
+          this._adversaryStream = null;
+        }
         this._worldFacts = { files: /* @__PURE__ */ new Map(), lastTest: {}, lastLists: /* @__PURE__ */ new Map() };
         this._argCohorts.clear();
         this._adversaryRedundantSignals.clear();
@@ -574800,6 +575601,28 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             });
           }
           this._runReg61Check(turn, toolCallLog, messages2);
+          if (turn > stagnationCooldownUntilTurn) {
+            const failingApproach = this._detectFailingApproach(turn);
+            if (failingApproach) {
+              messages2.push({ role: "system", content: failingApproach });
+              stagnationCooldownUntilTurn = turn + 4;
+              this.emit({
+                type: "adversary_reaction",
+                adversary: {
+                  class: "guidance",
+                  shortText: "Failing approach — same error recurring; diagnose root cause",
+                  confidence: 0.9,
+                  details: failingApproach
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              this.emit({
+                type: "status",
+                content: `FAILING-APPROACH detected at turn ${turn} — injected root-cause directive`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
           const REG58_NO_WRITE_BUDGET = 30;
           if (turn > stagnationCooldownUntilTurn && this._lastFileWriteTurn >= 0 && turn - this._lastFileWriteTurn >= REG58_NO_WRITE_BUDGET && process.env["OMNIUS_DISABLE_REG58"] !== "1") {
             const gap = turn - this._lastFileWriteTurn;
@@ -576795,7 +577618,8 @@ Corrective action: try a different approach first: read relevant files, adjust a
                 }
                 toolCallBudget.set(tc.name, budgetRemaining - 1);
               }
-              const toolFingerprint = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
+              const exactToolFingerprint = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
+              const toolFingerprint = this._resolveReadCoverageFingerprint(tc.name, tc.arguments ?? {}, exactToolFingerprint);
               if (tc.name === "memory_write" && noopedMemoryWriteFingerprints.has(toolFingerprint)) {
                 this.emit({
                   type: "tool_call",
@@ -577214,14 +578038,16 @@ Respond with EXACTLY this structure before your next tool call:
                   const paths = realMutationPaths.length > 0 ? realMutationPaths : this._extractToolTargetPaths(tc.name, tc.arguments, result);
                   for (const p2 of paths) {
                     const prev = this._worldFacts.files.get(p2);
+                    const nextWriteCount = (prev?.writeCount ?? 0) + 1;
                     this._worldFacts.files.set(p2, {
                       exists: true,
                       size: prev?.size,
                       hashSample: prev?.hashSample,
                       lastSeenTurn: turn,
                       lastWriteTurn: turn,
-                      writeCount: (prev?.writeCount ?? 0) + 1
+                      writeCount: nextWriteCount
                     });
+                    this._evidenceLedger.markMutated(p2, nextWriteCount, turn);
                   }
                   if (paths.length > 0) {
                     this._writesSinceLastTodoWrite += paths.length;
@@ -577259,6 +578085,19 @@ Respond with EXACTLY this structure before your next tool call:
                       writeCount: prev?.writeCount
                     });
                   }
+                  if (p2 && result.success && result.output) {
+                    const rOffset = typeof tc.arguments?.["offset"] === "number" ? tc.arguments["offset"] : void 0;
+                    const rLimit = typeof tc.arguments?.["limit"] === "number" ? tc.arguments["limit"] : void 0;
+                    const start3 = rOffset === void 0 && rLimit === void 0 ? 0 : Math.max(1, rOffset ?? 1);
+                    const end = rOffset === void 0 && rLimit === void 0 ? Number.POSITIVE_INFINITY : rLimit !== void 0 ? Math.max(1, rOffset ?? 1) + Math.max(0, rLimit) - 1 : Number.POSITIVE_INFINITY;
+                    this._evidenceLedger.recordRead({
+                      path: p2,
+                      content: result.output,
+                      range: { start: start3, end },
+                      fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
+                      turn
+                    });
+                  }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
                     try {
                       const existing = this._fileSummaryStore.get(p2);
@@ -577797,6 +578636,9 @@ Respond with EXACTLY this structure before your next tool call:
                   result: tc.name === "shell" ? this._buildShellCacheResult(tc.arguments, result) : (result.output ?? "").slice(0, 2e3),
                   compacted: false
                 });
+                if (isReadLike && result.success) {
+                  this._registerReadCoverage(tc.name, tc.arguments ?? {}, toolFingerprint);
+                }
                 if (recentToolResults.size > 500) {
                   const firstKey = recentToolResults.keys().next().value;
                   if (firstKey !== void 0) {
@@ -577826,6 +578668,10 @@ Respond with EXACTLY this structure before your next tool call:
                       if (key.includes(mp))
                         recentToolResults.delete(key);
                     }
+                    for (const covKey of Array.from(this._readCoverage.keys())) {
+                      if (covKey.includes(mp))
+                        this._readCoverage.delete(covKey);
+                    }
                   }
                 } else if (dedupHitCount.size > 0) {
                   dedupHitCount.clear();
@@ -577984,6 +578830,44 @@ 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 && typeof result.output === "string" && this.backend && typeof this.backend.chatCompletion === "function") {
+                const a2 = tc.arguments ?? {};
+                const hasSmallRange = typeof a2["limit"] === "number" && a2["limit"] <= 80;
+                const lineCount = result.output.split("\n").length;
+                if (shouldBranchRead(result.output.length, lineCount, hasSmallRange)) {
+                  const p2 = String(a2["path"] ?? a2["file"] ?? a2["file_path"] ?? "");
+                  const lastAssistant = [...messages2].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+                  const query = [
+                    this._taskState.goal ?? "",
+                    typeof lastAssistant?.content === "string" ? lastAssistant.content : ""
+                  ].join(" ").trim().slice(0, 400) || "key facts, configuration, and structure";
+                  try {
+                    const ev = await extractEvidence({
+                      path: p2,
+                      query,
+                      content: result.output,
+                      fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
+                      backend: this.backend,
+                      timeoutMs: 3e4
+                    });
+                    output = [
+                      `[BRANCH-EXTRACT] ${p2} is large (${lineCount} lines, ${result.output.length} chars) — read in an isolated branch so it does not flood your context.`,
+                      `Distilled for: "${query.slice(0, 160)}"`,
+                      `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, or extract_evidence(path, query) with a sharper question.`
+                    ].join("\n");
+                    this.emit({
+                      type: "status",
+                      toolName: tc.name,
+                      content: `Branch-extract: ${p2} (${lineCount} lines) → ${ev.injectedChars} chars to context (${(result.output.length / Math.max(1, ev.injectedChars)).toFixed(0)}× smaller)`,
+                      turn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  } catch {
+                  }
+                }
+              }
               if (criticGuidance) {
                 output += `
 
@@ -580527,11 +581411,9 @@ ${errOutput}`);
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         try {
-          const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = __require("node:fs");
-          const { join: join179 } = __require("node:path");
-          const resultsDir = join179(this.omniusStateDir(), "tool-results");
-          mkdirSync106(resultsDir, { recursive: true });
-          writeFileSync91(join179(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
+          const resultsDir = _pathJoin(this.omniusStateDir(), "tool-results");
+          _fsMkdirSync(resultsDir, { recursive: true });
+          _fsWriteFileSync(_pathJoin(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
 # Turn: ${turn}
 # Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
 # Size: ${result.output.length} chars, ${lineCount} lines
@@ -580539,8 +581421,7 @@ ${errOutput}`);
 ${result.output}`, "utf-8");
         } catch {
         }
-        const { join: _pj } = __require("node:path");
-        const savedPath = _pj(this.omniusStateDir(), "tool-results", `${handleId}.txt`);
+        const savedPath = _pathJoin(this.omniusStateDir(), "tool-results", `${handleId}.txt`);
         const folded = this.foldOutput(modelContent, maxLen);
         return this.wrapToolOutputForModel(toolName, `[Tool output truncated — ${result.output.length} chars, ${lineCount} lines]
 Full output saved to: ${savedPath}
@@ -581817,6 +582698,20 @@ ${trimmedNew}`;
        */
       adversaryObserve(messages2, turn) {
         const recent = messages2.slice(-6);
+        if (this._adversaryStream) {
+          const lastAssistantMsg = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+          const assistantText = typeof lastAssistantMsg?.content === "string" ? lastAssistantMsg.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim() : "";
+          if (assistantText) {
+            this._adversaryStream.observe({
+              turn,
+              assistantText,
+              recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({ tool: o2.tool, succeeded: o2.succeeded, preview: o2.preview })),
+              claimsCompletion: /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(assistantText)
+            });
+            void this._adversaryStream.tick().catch(() => {
+            });
+          }
+        }
         for (const msg of recent) {
           if (msg.role === "tool" && typeof msg.content === "string") {
             const isError2 = msg.content.startsWith("Error:") || /^(FAIL|ERR!|TypeError)/i.test(msg.content);
@@ -583058,7 +583953,7 @@ ${transcript}`
         const allTools = Array.from(this.tools.values()).filter((tool) => tool.name !== "tool_search");
         const tier = this.options.modelTier ?? "large";
         const taskGoal = this._taskState.goal || "";
-        const STOPWORDS3 = /* @__PURE__ */ new Set([
+        const STOPWORDS4 = /* @__PURE__ */ new Set([
           "with",
           "that",
           "this",
@@ -583144,7 +584039,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
         const getIndexLabel = (tool) => {
           const meta = getCustomToolMetadata(tool);
           const desc = `${getDesc(tool)} ${aliasText(tool)} ${customToolSearchText(tool)}`.toLowerCase().replace(/[`"'()[\]{}:;,.!?/\\|-]+/g, " ");
-          const keywords2 = Array.from(new Set(desc.split(/\s+/).filter((word2) => word2.length > 2 && !STOPWORDS3.has(word2) && !tool.name.toLowerCase().includes(word2)))).slice(0, 4);
+          const keywords2 = Array.from(new Set(desc.split(/\s+/).filter((word2) => word2.length > 2 && !STOPWORDS4.has(word2) && !tool.name.toLowerCase().includes(word2)))).slice(0, 4);
           const base3 = keywords2.length > 0 ? `${tool.name}(${keywords2.join(",")})` : tool.name;
           if (!meta)
             return base3;
@@ -586963,16 +587858,16 @@ function parseSimpleYaml(text2) {
     const match = withoutComment.match(/^(\s*)([A-Za-z0-9_-]+):(?:\s*(.*))?$/);
     if (!match)
       continue;
-    const indent = match[1].length;
+    const indent2 = match[1].length;
     const key = match[2];
     const rawValue = match[3] ?? "";
-    while (stack.length > 1 && indent <= stack[stack.length - 1].indent)
+    while (stack.length > 1 && indent2 <= stack[stack.length - 1].indent)
       stack.pop();
     const parent = stack[stack.length - 1].value;
     if (!rawValue.trim()) {
       const nested = {};
       parent[key] = nested;
-      stack.push({ indent, value: nested });
+      stack.push({ indent: indent2, value: nested });
     } else {
       parent[key] = parseScalar(rawValue.trim());
     }
@@ -589220,7 +590115,7 @@ function readServicesManifest(missionDir) {
     commandArrayField = null;
   };
   for (const line of content.split("\n")) {
-    const indent = line.match(/^\s*/)?.[0].length ?? 0;
+    const indent2 = line.match(/^\s*/)?.[0].length ?? 0;
     const t2 = line.trim();
     if (!t2)
       continue;
@@ -589270,12 +590165,12 @@ function readServicesManifest(missionDir) {
       continue;
     }
     if (section === "services" && curSvc.name) {
-      if (serviceArrayField === "dependsOn" && indent >= 6 && t2.startsWith("- ")) {
+      if (serviceArrayField === "dependsOn" && indent2 >= 6 && t2.startsWith("- ")) {
         curSvc.dependsOn ??= [];
         curSvc.dependsOn.push(unquoteScalar(t2.slice(2)));
         continue;
       }
-      if (inEnvironment && indent >= 6 && /^[A-Za-z_][A-Za-z0-9_.-]*:/.test(t2)) {
+      if (inEnvironment && indent2 >= 6 && /^[A-Za-z_][A-Za-z0-9_.-]*:/.test(t2)) {
         const idx = t2.indexOf(":");
         curSvc.environment ??= {};
         curSvc.environment[t2.slice(0, idx).trim()] = unquoteScalar(t2.slice(idx + 1));
@@ -589303,7 +590198,7 @@ function readServicesManifest(missionDir) {
       }
     }
     if (section === "commands" && curCmd.name) {
-      if (commandArrayField === "requiresServices" && indent >= 6 && t2.startsWith("- ")) {
+      if (commandArrayField === "requiresServices" && indent2 >= 6 && t2.startsWith("- ")) {
         curCmd.requiresServices ??= [];
         curCmd.requiresServices.push(unquoteScalar(t2.slice(2)));
         continue;
@@ -589875,14 +590770,14 @@ function buildFolderListing(dirPath, cwd4, limit = 200) {
     for (const d2 of dirs) {
       if (count >= limit)
         break;
-      const indent = "  ".repeat(depth);
-      lines.push(`${indent}- ${d2}/`);
+      const indent2 = "  ".repeat(depth);
+      lines.push(`${indent2}- ${d2}/`);
       count++;
     }
     for (const f2 of files) {
       if (count >= limit)
         break;
-      const indent = "  ".repeat(depth);
+      const indent2 = "  ".repeat(depth);
       const full = join117(current, f2);
       let meta = "?";
       try {
@@ -589900,7 +590795,7 @@ function buildFolderListing(dirPath, cwd4, limit = 200) {
       } catch {
         meta = "?";
       }
-      lines.push(`${indent}- ${f2} (${meta})`);
+      lines.push(`${indent2}- ${f2} (${meta})`);
       count++;
     }
     if (count < limit) {
@@ -602480,7 +603375,7 @@ function keywords(text2) {
   const seen = /* @__PURE__ */ new Set();
   for (const raw of text2.toLowerCase().match(/[a-z0-9_.-]{4,}/g) ?? []) {
     const token = raw.replace(/^[.-]+|[.-]+$/g, "");
-    if (token.length < 4 || STOPWORDS2.has(token) || seen.has(token)) continue;
+    if (token.length < 4 || STOPWORDS3.has(token) || seen.has(token)) continue;
     seen.add(token);
     out.push(token);
     if (out.length >= 8) break;
@@ -602765,7 +603660,7 @@ function renderScopedPersonalityContext(doc) {
 function buildScopedPersonalityContext(scope) {
   return renderScopedPersonalityContext(loadScopedPersonality(scope));
 }
-var PROFILE_VERSION, MAX_PROFILE_OBSERVATIONS, MAX_PROFILE_DURABLE_OBSERVATIONS, MAX_PROFILE_RELATIONSHIP_EVENTS, MAX_PROFILE_SAMPLES, MAX_PROFILE_TAGS, STOPWORDS2;
+var PROFILE_VERSION, MAX_PROFILE_OBSERVATIONS, MAX_PROFILE_DURABLE_OBSERVATIONS, MAX_PROFILE_RELATIONSHIP_EVENTS, MAX_PROFILE_SAMPLES, MAX_PROFILE_TAGS, STOPWORDS3;
 var init_scoped_personality = __esm({
   "packages/cli/src/tui/scoped-personality.ts"() {
     "use strict";
@@ -602775,7 +603670,7 @@ var init_scoped_personality = __esm({
     MAX_PROFILE_RELATIONSHIP_EVENTS = 120;
     MAX_PROFILE_SAMPLES = 16;
     MAX_PROFILE_TAGS = 12;
-    STOPWORDS2 = /* @__PURE__ */ new Set([
+    STOPWORDS3 = /* @__PURE__ */ new Set([
       "about",
       "after",
       "again",
@@ -613475,8 +614370,8 @@ ${CONTENT_BG_SEQ}`);
         for (const pattern of patterns) {
           const match = visible.match(pattern);
           if (match?.[1]) {
-            const indent = match[1];
-            return indent.slice(0, Math.min(indent.length, Math.max(0, width - 4)));
+            const indent2 = match[1];
+            return indent2.slice(0, Math.min(indent2.length, Math.max(0, width - 4)));
           }
         }
         const leading = visible.match(/^\s*/)?.[0] ?? "";
@@ -618220,11 +619115,11 @@ ${c3.cyan(OMNIUS_FIRST_RUN_BANNER)}
     return `  ${c3.dim("│")}${content}${" ".repeat(pad)}${c3.dim("│")}
 `;
   };
-  const boxWrappedDimLine = (content, indent = "  ") => {
+  const boxWrappedDimLine = (content, indent2 = "  ") => {
     const formatted = formatMarkdownBlock(content);
-    const lines = wrapText2(formatted, Math.max(1, boxW - visibleLen2(indent)));
+    const lines = wrapText2(formatted, Math.max(1, boxW - visibleLen2(indent2)));
     for (const line of lines) {
-      process.stdout.write(boxLine(`${indent}${c3.dim(line)}`));
+      process.stdout.write(boxLine(`${indent2}${c3.dim(line)}`));
     }
   };
   const hLine = (ch) => `  ${c3.dim(ch + "─".repeat(boxW) + (ch === "╭" ? "╮" : ch === "├" ? "┤" : "╯"))}
@@ -698982,7 +699877,7 @@ function getAsyncApiSpec() {
     }
   };
 }
-function jsonToYaml(value2, indent = 0) {
+function jsonToYaml(value2, indent2 = 0) {
   const pad = (n2) => "  ".repeat(n2);
   if (value2 === null) return "null";
   if (value2 === void 0) return "null";
@@ -698992,7 +699887,7 @@ function jsonToYaml(value2, indent = 0) {
     if (value2.length === 0) return '""';
     if (/[\n\r]/.test(value2)) {
       const lines = value2.replace(/\r\n?/g, "\n").split("\n");
-      return "|-\n" + lines.map((l2) => pad(indent + 1) + l2).join("\n");
+      return "|-\n" + lines.map((l2) => pad(indent2 + 1) + l2).join("\n");
     }
     if (/^(true|false|null|yes|no|on|off|~|\d|-\d|\.\d|\.inf|\.nan|@|`|\*|&|!|\?|\||>|%|"|')/i.test(value2) || /[#:,\[\]{}]/.test(value2) || /^\s|\s$/.test(value2)) {
       return JSON.stringify(value2);
@@ -699002,13 +699897,13 @@ function jsonToYaml(value2, indent = 0) {
   if (Array.isArray(value2)) {
     if (value2.length === 0) return "[]";
     return "\n" + value2.map((item) => {
-      const rendered = jsonToYaml(item, indent + 1);
+      const rendered = jsonToYaml(item, indent2 + 1);
       if (rendered.startsWith("\n")) {
-        return pad(indent) + "-" + rendered.replace(/^\n/, "\n");
+        return pad(indent2) + "-" + rendered.replace(/^\n/, "\n");
       }
       const lines = rendered.split("\n");
-      if (lines.length === 1) return pad(indent) + "- " + lines[0];
-      return pad(indent) + "- " + lines[0] + "\n" + lines.slice(1).map((l2) => pad(indent + 1) + l2.replace(/^  /, "")).join("\n");
+      if (lines.length === 1) return pad(indent2) + "- " + lines[0];
+      return pad(indent2) + "- " + lines[0] + "\n" + lines.slice(1).map((l2) => pad(indent2 + 1) + l2.replace(/^  /, "")).join("\n");
     }).join("\n");
   }
   if (typeof value2 === "object") {
@@ -699018,11 +699913,11 @@ function jsonToYaml(value2, indent = 0) {
     return "\n" + keys.map((k) => {
       const v = obj[k];
       const safeKey = /^[a-zA-Z_][a-zA-Z0-9_./-]*$/.test(k) && !/^(true|false|null|yes|no|on|off)$/i.test(k) ? k : JSON.stringify(k);
-      const rendered = jsonToYaml(v, indent + 1);
+      const rendered = jsonToYaml(v, indent2 + 1);
       if (rendered.startsWith("\n")) {
-        return pad(indent) + safeKey + ":" + rendered;
+        return pad(indent2) + safeKey + ":" + rendered;
       }
-      return pad(indent) + safeKey + ": " + rendered;
+      return pad(indent2) + safeKey + ": " + rendered;
     }).join("\n");
   }
   return JSON.stringify(value2);
@@ -713725,14 +714620,18 @@ ${entry.fullContent}`
               adversaryBuffer.splice(0, adversaryBuffer.length - 50);
           }
           if (lm.intervention) {
+            const lines = [String(lm.intervention)];
+            if (lm.details && showAdversary) {
+              for (const d2 of String(lm.details).split("\n").filter(Boolean))
+                lines.push(d2);
+            }
             contentWrite(() => {
-              renderWarning(`Adversary: ${lm.intervention}`);
-            });
-          } else if (lm.details && showAdversary) {
-            contentWrite(() => {
-              renderInfo(
-                `Adversary details: ${String(lm.details).split("\n").filter(Boolean).join(" | ")}`
-              );
+              renderBoxedBlock({
+                title: "⚠ Adversary",
+                lines,
+                colorCode: ADVERSARY_COLOR,
+                kind: "plain"
+              });
             });
           }
         }
@@ -713740,16 +714639,24 @@ ${entry.fullContent}`
       case "adversary_reaction":
         if (event.adversary) {
           const adv = event.adversary;
-          const conf = adv.confidence != null ? ` (${Math.round(adv.confidence * 100)}%)` : "";
-          const text2 = adv.shortText + conf;
-          contentWrite(() => {
-            renderWarning(`Adversary ${adv.class}: ${text2}`);
-          });
+          const conf = adv.confidence != null ? `${Math.round(adv.confidence * 100)}%` : "";
+          const lines = [adv.shortText];
           if (adv.details) {
+            for (const d2 of String(adv.details).split("\n").filter(Boolean))
+              lines.push(d2);
             adversaryBuffer.push(adv.details);
             if (adversaryBuffer.length > 50)
               adversaryBuffer.splice(0, adversaryBuffer.length - 50);
           }
+          contentWrite(() => {
+            renderBoxedBlock({
+              title: `⚠ Adversary · ${adv.class}`,
+              metrics: conf,
+              lines,
+              colorCode: ADVERSARY_COLOR,
+              kind: "plain"
+            });
+          });
         }
         break;
     }
@@ -720435,7 +721342,7 @@ Rules:
     process.exit(1);
   }
 }
-var NEXUS_DIRECTORY_ORIGIN3, NEXUS_AGENT_DIRECTORY_URL, NEXUS_SPONSORS_URL3, _generativeProgressSink, _interactiveSessionActive, _interactiveSessionReason, _voiceChatSession2, taskManager, _apiCallbacks, _shellToolRef, _replToolRef, _fullSubAgentToolRef, _agentToolRef, _sendMessageToolRef, _agentLifecycleMgr, _activeRunnerRef, _parentRunnerForArchive, _wireSubAgentCallbacks, _wireAgentToolCallbacks, _wireSubAgentToolCallbacks, _autoUpdatedThisSession, _mcpManager, _pluginManager, _mcpTools, SELF_IMPROVE_INTERVAL, _tasksSinceImprove;
+var NEXUS_DIRECTORY_ORIGIN3, NEXUS_AGENT_DIRECTORY_URL, NEXUS_SPONSORS_URL3, ADVERSARY_COLOR, _generativeProgressSink, _interactiveSessionActive, _interactiveSessionReason, _voiceChatSession2, taskManager, _apiCallbacks, _shellToolRef, _replToolRef, _fullSubAgentToolRef, _agentToolRef, _sendMessageToolRef, _agentLifecycleMgr, _activeRunnerRef, _parentRunnerForArchive, _wireSubAgentCallbacks, _wireAgentToolCallbacks, _wireSubAgentToolCallbacks, _autoUpdatedThisSession, _mcpManager, _pluginManager, _mcpTools, SELF_IMPROVE_INTERVAL, _tasksSinceImprove;
 var init_interactive = __esm({
   "packages/cli/src/tui/interactive.ts"() {
     "use strict";
@@ -720501,6 +721408,7 @@ var init_interactive = __esm({
     NEXUS_DIRECTORY_ORIGIN3 = (process.env["OMNIUS_NEXUS_DIRECTORY_ORIGIN"] || process.env["OMNIUS_NEXUS_SIGNALING_SERVER"] || "https://openagents.nexus").replace(/\/+$/, "");
     NEXUS_AGENT_DIRECTORY_URL = `${NEXUS_DIRECTORY_ORIGIN3}/api/v1/directory`;
     NEXUS_SPONSORS_URL3 = `${NEXUS_DIRECTORY_ORIGIN3}/api/v1/sponsors`;
+    ADVERSARY_COLOR = 214;
     _generativeProgressSink = null;
     _interactiveSessionActive = false;
     _interactiveSessionReason = "";