omnius 1.0.557 → 1.0.558

package/dist/index.js

@@ -14857,14 +14857,14 @@ var init_file_edit = __esm({
           },
           expected_hash: {
             type: "string",
-            description: "SHA-256 from the most recent file_read for this file. The runner refuses unverified exact replacements that omit or mismatch this hash."
+            description: "Optional SHA-256 from file_read. When present, the edit is compare-and-swap protected against concurrent file changes; otherwise old_string must match current file text exactly."
           },
           dry_run: {
             type: "boolean",
             description: "Validate the edit and preview the diff without modifying disk."
           }
         },
-        required: ["path", "expected_hash"],
+        required: ["path"],
         allOf: [
           { anyOf: [{ required: ["old_string"] }, { required: ["old_string_base64"] }] },
           { anyOf: [{ required: ["new_string"] }, { required: ["new_string_base64"] }] }
@@ -29478,10 +29478,10 @@ var init_batch_edit = __esm({
                 },
                 expected_hash: {
                   type: "string",
-                  description: "SHA-256 from the most recent file_read for this file. All edits for a file must use the same verified hash."
+                  description: "Optional SHA-256 from file_read. When supplied, all edits for a file must use the same value and the atomic batch checks it before writing."
                 }
               },
-              required: ["path", "expected_hash"],
+              required: ["path"],
               allOf: [
                 { anyOf: [{ required: ["old_string"] }, { required: ["old_string_base64"] }] },
                 { anyOf: [{ required: ["new_string"] }, { required: ["new_string_base64"] }] }
@@ -579380,9 +579380,9 @@ var init_evidenceLedger = __esm({
         const { path: path16, content, range, fileVersion, turn } = input;
         if (!path16 || !content)
           return;
-        const built = buildExtract(content);
-        if (input.fidelity)
-          built.fidelity = input.fidelity;
+        const built = input.fidelity === "full" ? { text: content, fidelity: "full" } : buildExtract(content);
+        if (input.fidelity === "extract")
+          built.fidelity = "extract";
         const existing = this.entries.get(path16);
         if (existing && existing.readVersion === fileVersion && !existing.stale) {
           const keepNew = input.fidelity === "extract" || built.text.length >= existing.content.length;
@@ -580968,7 +580968,7 @@ ${input.error}`;
     diagnoses.add("tool-failure");
   if (input.failureKind)
     diagnoses.add(input.failureKind);
-  if (out.includes("[FOCUS SUPERVISOR BLOCK]")) {
+  if (!input.success && out.includes("[FOCUS SUPERVISOR BLOCK]")) {
     diagnoses.add("focus-supervisor-block");
   }
   if (input.toolName === "task_status" && /Task not found/i.test(out)) {
@@ -584760,12 +584760,12 @@ var init_completion_resolution_verifier = __esm({
 import { createHash as createHash33 } from "node:crypto";
 function buildBranchExtractionBrief(input) {
   const path16 = cleanBriefText(input.path, 320) || "the requested file";
-  const intent = firstBriefText([
+  const intent = fileLocalDiscoveryQuestion(firstBriefText([
     input.assistantIntent,
     input.trajectoryNextAction,
     input.currentStep
-  ]);
-  const openQuestion = cleanBriefText(input.trajectoryOpenQuestion, 280);
+  ]), path16);
+  const openQuestion = fileLocalDiscoveryQuestion(cleanBriefText(input.trajectoryOpenQuestion, 280), path16);
   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.`;
@@ -584779,11 +584779,12 @@ function buildBranchExtractionBrief(input) {
     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 relatedFailure = fileLocalFailureForPath(input.recentFailure, path16);
   const requirementQuestions = uniqueBriefLines([
     openQuestion,
     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)}` : ""
+    input.currentStep && input.currentStep !== intent ? fileLocalDiscoveryQuestion(input.currentStep, path16) : "",
+    relatedFailure ? `Which file-local declaration, value, or behavior explains this unresolved failure: ${relatedFailure}` : ""
   ]).slice(0, 3);
   if (requirementQuestions.length === 0) {
     requirementQuestions.push(`Which declarations, values, and behavior in this file are required for the next narrow action?`);
@@ -584879,6 +584880,28 @@ function uniqueBriefLines(values) {
 function asActionClause(value2) {
   return cleanBriefText(value2, 320).replace(/^to\s+/i, "").replace(/[.?!]+$/, "").replace(/^([A-Z])/, (match) => match.toLowerCase());
 }
+function fileLocalDiscoveryQuestion(value2, path16) {
+  const clean5 = cleanBriefText(value2, 320);
+  if (!clean5)
+    return "";
+  if (/^(?:exploring|editing|reading|verifying|current|next(?:_valid)?_action)\s*:/i.test(clean5) || /\b(?:controller state|branch-extract|active context frame|file_read block|runtime repair|recovery required)\b/i.test(clean5)) {
+    return "";
+  }
+  const referencedPaths = clean5.match(/[\w./-]+\.(?:[cm]?[jt]sx?|py|cpp|cxx|h(?:pp)?|md|json|yaml|yml)/g) ?? [];
+  const targetBase = path16.split("/").pop() ?? path16;
+  if (referencedPaths.length > 0 && !referencedPaths.some((candidate) => candidate === targetBase || path16.endsWith(candidate))) {
+    return "";
+  }
+  return clean5;
+}
+function fileLocalFailureForPath(value2, path16) {
+  const clean5 = fileLocalDiscoveryQuestion(value2, path16);
+  if (!clean5)
+    return "";
+  const targetBase = path16.split("/").pop() ?? path16;
+  const mentionsTarget = clean5.includes(targetBase) || clean5.includes(path16);
+  return mentionsTarget || !/[\w./-]+\.(?:[cm]?[jt]sx?|py|cpp|cxx|h(?:pp)?)/.test(clean5) ? clean5 : "";
+}
 function selectWindows(lines, terms2) {
   const matched = [];
   for (let i2 = 0; i2 < lines.length; i2++) {
@@ -589379,9 +589402,6 @@ var init_agenticRunner = __esm({
       _branchEvidenceCache = /* @__PURE__ */ new Map();
       /** Latest curated node per canonical path for safe post-compaction recovery. */
       _branchEvidenceByPath = /* @__PURE__ */ new Map();
-      /** Exact read fingerprints resolved from canonical evidence, not a fresh tool call. */
-      _resolvedReadEvidence = /* @__PURE__ */ new Map();
-      _deterministicNarrowReadFallbacks = /* @__PURE__ */ new Set();
       // 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 —
@@ -592686,21 +592706,13 @@ ${extras.join("\n")}`;
         });
       }
       /**
-       * Very small local models benefit from forced next-action rails when they
-       * become lost. Medium and large models need room to investigate, compare
-       * hypotheses, and choose a verifier appropriate to new evidence. Safety,
-       * steering, and evidence-before-mutation remain universal; only controller
-       * action coercion is tier-gated here. An operator can override for a model
-       * whose observed behavior differs from its nominal tier.
+       * Action rails are an explicitly opt-in diagnostic experiment, never a
+       * normal-model policy. They created deadlocks by denying the very reads and
+       * edits needed to revise a hypothesis. Evidence and the tools' own atomic
+       * checks remain available without a controller admission gate.
        */
       _enforcesStrictActionBoundaries() {
-        const tier = this.options.modelTier ?? "large";
-        if (tier !== "small")
-          return false;
-        const override = process.env["OMNIUS_STRICT_ACTION_BOUNDARIES"];
-        if (override === "0")
-          return false;
-        return true;
+        return process.env["OMNIUS_ENABLE_EXPERIMENTAL_ACTION_GATES"] === "1";
       }
       /** Consecutive preflight blocks before the gate yields instead of blocking. */
       static COMPILE_FIX_GATE_YIELD_AFTER = 3;
@@ -593184,6 +593196,8 @@ ${result.output ?? ""}`;
         return openTodoLeaves(todos);
       }
       _todoExpansionRequiredBlocker(toolName) {
+        if (!this._enforcesStrictActionBoundaries())
+          return null;
         if (!this._todoWriteAvailable())
           return null;
         if (toolName === "todo_write" || toolName === "todo_read")
@@ -597814,57 +597828,28 @@ ${notice}`;
         }
       }
       _canonicalReadEvidencePayload(canonicalPath, contentHash2) {
+        const evidence = this._evidenceLedger.get(canonicalPath);
+        if (evidence && !evidence.stale && evidence.contentHash === contentHash2 && evidence.fidelity === "full" && this._mustHonorExplicitFullFileRead(Buffer.byteLength(evidence.content, "utf8"), evidence.content.split("\n").length, this._branchRoutingContextWindow())) {
+          return evidence.content;
+        }
         const branch = this._branchEvidenceByPath.get(canonicalPath);
-        if (branch && branch.contentHash === contentHash2 && branch.taskEpoch === this._taskEpoch) {
+        if (branch && branch.contentHash === contentHash2 && branch.taskEpoch === this._taskEpoch && branch.contractComplete) {
           return branch.output;
         }
         return null;
       }
       _rehydrateResolvedReadEvidence(input) {
-        const previous = this._resolvedReadEvidence.get(input.fingerprint);
-        const handle2 = previous?.handle ?? `evidence:${input.canonicalPath}:${input.contentHash.slice(0, 16)}`;
-        this._resolvedReadEvidence.set(input.fingerprint, {
-          state: "resolved_from_cache",
-          handle: handle2,
-          path: input.canonicalPath,
-          contentHash: input.contentHash,
-          resolvedTurn: input.turn,
-          consumed: false
-        });
         return [
           "[REHYDRATED_FILE_EVIDENCE]",
-          `handle=${handle2}`,
-          "fingerprint_state=resolved_from_cache",
           `path=${input.canonicalPath}`,
+          "source=canonical_branch_cache",
           `sha256=${input.contentHash}`,
-          "Facts below are canonical current-run evidence. Consume these facts in the next decision; do not repeat the identical read.",
+          "This is an unchanged, complete branch extraction. A later file_read may still execute whenever current source or broader coverage is needed.",
           "[CANONICAL_FACTS]",
           input.payload.slice(0, 7e3),
           "[/CANONICAL_FACTS]"
         ].join("\n");
       }
-      _rejectRepeatedResolvedRead(tc, messages2) {
-        if (tc.name !== "file_read") {
-          for (const state2 of this._resolvedReadEvidence.values()) {
-            state2.consumed = true;
-          }
-          return null;
-        }
-        const fingerprint = this._buildToolFingerprint(tc.name, tc.arguments);
-        const state = this._resolvedReadEvidence.get(fingerprint);
-        if (!state)
-          return null;
-        const latestAssistant = [...messages2].reverse().find((message2) => message2.role === "assistant" && typeof message2.content === "string");
-        if (latestAssistant && typeof latestAssistant.content === "string" && latestAssistant.content.includes(state.handle)) {
-          state.consumed = true;
-        }
-        return [
-          "[REPEATED_READ_REJECTED]",
-          `handle=${state.handle}`,
-          `fingerprint_state=${state.state}`,
-          state.consumed ? "The evidence handle was acknowledged, but an identical read cannot add facts. Change file/range/query scope or take the evidence-backed next action." : "Consume the rehydrated evidence handle in your next decision before requesting another read. Change file/range/query scope if a different fact is required."
-        ].join("\n");
-      }
       async _drainPendingSteeringMessages(messages2, turn) {
         this.drainPendingRuntimeGuidance(turn);
         const pending2 = this.pendingSteeringInputs.filter((record) => (record.state === "queued" || record.state === "acknowledged") && (!record.taskEpoch || record.taskEpoch === this._taskEpoch));
@@ -598265,6 +598250,16 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
       _mustInlineSmallFileRead(selectedBytes, selectedLines) {
         return selectedBytes <= 8e3 && selectedLines <= 200;
       }
+      /**
+       * `mode:"full"` is a first-class model choice, not a request for a wrapper.
+       * Honor it for a bounded source body that still leaves normal output room;
+       * truly overwhelming files continue through the isolated extractor.
+       */
+      _mustHonorExplicitFullFileRead(selectedBytes, selectedLines, contextWindow) {
+        const projected = estimateFileReadInjectionTokens(selectedBytes, selectedLines);
+        const cap = Math.max(4096, Math.min(8192, Math.floor(Math.max(0, contextWindow) * 0.15)));
+        return selectedBytes <= 32e3 && selectedLines <= 800 && projected <= cap;
+      }
       /**
        * Route using the same sanitized, model-facing request shape that will be
        * sent after the tool turn—not the unreduced historical transcript. Using
@@ -598374,8 +598369,10 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
         });
         const requestedMode = this._fileReadMode(input.args);
         const explicitExtraction = requestedMode === "extract";
+        const explicitFull = requestedMode === "full";
         const inlineSmallRead = this._mustInlineSmallFileRead(selectedBytes, selectedLines.length);
-        if ((!decision2.branch || inlineSmallRead) && !explicitExtraction) {
+        const honorFull = explicitFull && this._mustHonorExplicitFullFileRead(selectedBytes, selectedLines.length, contextWindow);
+        if ((!decision2.branch || inlineSmallRead || honorFull) && !explicitExtraction) {
           input.batchBudget.inlineTokens += decision2.projectedReadTokens;
           input.batchBudget.reservations.set(input.callId, decision2.projectedReadTokens);
           return null;
@@ -598395,7 +598392,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
         const branchRequestId = `branch:${this._taskEpoch}:${_createHash("sha256").update(`${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`).digest("hex").slice(0, 20)}`;
         const cacheKey = `${this._taskEpoch}|${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
         const cached2 = this._branchEvidenceCache.get(cacheKey);
-        if (cached2) {
+        if (cached2?.contractComplete) {
           const fingerprint = this._buildToolFingerprint(input.toolName, input.args);
           const rehydrated = this._rehydrateResolvedReadEvidence({
             fingerprint,
@@ -598407,7 +598404,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
           this.emit({
             type: "status",
             toolName: input.toolName,
-            content: `Branch-extract cache rehydrated: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint} fingerprint_state=resolved_from_cache`,
+            content: `Complete branch extraction reused: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint}`,
             turn: input.turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -598459,17 +598456,17 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
           `[VERIFIED_RUNTIME_FILE_READ] request_id=${branchRequestId} task_epoch=${this._taskEpoch}`,
           `routing=${explicitExtraction ? "manual" : "mandatory"} reasons=${decision2.reasons.join(",") || "explicit_extract"} 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:`,
+          `[EXTRACTION CONTRACT]`,
+          `Task: ${branchBrief.discoveryContract?.goalAnchor ?? this._taskState.currentStep}`,
+          `Question: ${branchBrief.request}`,
+          `Requirements:`,
           ...(branchBrief.discoveryContract?.requirements ?? []).map((requirement) => `- ${requirement.id}${requirement.required ? " [required]" : ""}: ${requirement.question}`),
           `Stop conditions: ${(branchBrief.discoveryContract?.completionCriteria ?? []).join(" | ")}`,
           `[CURATED SEGMENTS]`,
           ev.claim,
           ...requirementCoverage,
           `provenance=content:${ev.provenance.contentHash} searches:${ev.provenance.searchRounds.length} ranges:${ev.provenance.exploredRanges.map((range) => `L${range.startLine}-L${range.endLine}`).join(",")}`,
-          ev.contractComplete ? `Contract: every declared requirement has anchored evidence. Use these anchors as evidence; file_read(mode="full") remains available when live admission permits it.` : `Contract: this extraction is PARTIAL. Do not treat it as sufficient for a mutation that depends on an unresolved requirement; execute that requirement's listed bounded recovery. Do not use shell/cat to bypass context routing.`
+          ev.contractComplete ? `Coverage: complete; every declared requirement has anchored evidence.` : `Coverage: partial; unresolved requirements include their source-based reason and suggested next evidence query. This extract is advisory and does not restrict other tool calls.`
         ].join("\n");
         const outputBudgetChars = Math.max(800, decision2.fractionLimitTokens * 4);
         let output = verboseOutput;
@@ -598479,7 +598476,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
             `[BRANCH-EXTRACT v2] path=${rawPath} sha256=${fullHash}`,
             `[VERIFIED_RUNTIME_FILE_READ] request_id=${branchRequestId} task_epoch=${this._taskEpoch}`,
             `routing=${decision2.reasons.join(",")} projected=${decision2.projectedReadTokens}/${contextWindow}t limit=${decision2.fractionLimitTokens}t`,
-            `[DISCOVERY CONTRACT] required=${required || "next narrow file-local fact"}`,
+            `[EXTRACTION CONTRACT] required=${required || "next narrow file-local fact"}`,
             `[CURATED SEGMENTS]`
           ].join("\n");
           const suffix = [
@@ -598587,8 +598584,10 @@ ${suffix}`.slice(0, outputBudgetChars);
           safeContextTokens: this.contextLimits().compactionThreshold
         });
         const explicitExtraction = this._fileReadMode(input.args) === "extract";
+        const explicitFull = this._fileReadMode(input.args) === "full";
         const inlineSmallRead = this._mustInlineSmallFileRead(Buffer.byteLength(input.result.output, "utf8"), lines.length);
-        if ((!decision2.branch || inlineSmallRead) && !explicitExtraction) {
+        const honorFull = explicitFull && this._mustHonorExplicitFullFileRead(Buffer.byteLength(input.result.output, "utf8"), lines.length, contextWindow);
+        if ((!decision2.branch || inlineSmallRead || honorFull) && !explicitExtraction) {
           if (reservedForThisCall === 0) {
             input.batchBudget.inlineTokens += decision2.projectedReadTokens;
             input.batchBudget.reservations.set(input.callId, decision2.projectedReadTokens);
@@ -598622,12 +598621,12 @@ ${suffix}`.slice(0, outputBudgetChars);
           `[BRANCH-EXTRACT v2] path=${path16}`,
           `[VERIFIED_RUNTIME_FILE_READ] request_id=branch:${this._taskEpoch}:${input.callId} task_epoch=${this._taskEpoch}`,
           `routing=${explicitExtraction ? "manual" : "post-execution-failsafe"} reasons=${decision2.reasons.join(",") || "explicit_extract"} projected_read_tokens=${decision2.projectedReadTokens}`,
-          `[DISCOVERY CONTRACT] ${brief.request}`,
+          `[EXTRACTION CONTRACT] ${brief.request}`,
           `[CURATED SEGMENTS]`,
           ev.claim,
           ...requirementCoverage,
           `provenance=content:${ev.provenance.contentHash} ranges:${ev.provenance.exploredRanges.map((range) => `L${range.startLine}-L${range.endLine}`).join(",")}`,
-          ev.contractComplete ? "All declared requirements are grounded." : "PARTIAL contract: execute the listed bounded recovery before relying on an unresolved requirement."
+          ev.contractComplete ? "Coverage: complete; all declared requirements are grounded." : "Coverage: partial; unresolved requirements include a source-based recovery suggestion. This extract is advisory and does not restrict other tool calls."
         ].join("\n").slice(0, Math.max(800, decision2.fractionLimitTokens * 4));
         return {
           ...input.result,
@@ -600082,7 +600081,6 @@ ${dynamicProjectContext}`
         let lastShellPivotTurn = -1;
         const recentToolResults = /* @__PURE__ */ new Map();
         const exactFileReadObservations = /* @__PURE__ */ new Map();
-        const exactReadEvidenceEpochs = /* @__PURE__ */ new Map();
         let fileMutationEpoch = 0;
         const dedupHitCount = /* @__PURE__ */ new Map();
         const noopedMemoryWriteFingerprints = /* @__PURE__ */ new Set();
@@ -602515,17 +602513,6 @@ ${memoryLines.join("\n")}`
                 return { tc, output: steeringGate, success: false };
               }
               this._markFirstSteeringAffectedAction(tc.name, this._currentSteeringTurn);
-              const resolvedReadBlock = this._rejectRepeatedResolvedRead(tc, messages2);
-              if (resolvedReadBlock) {
-                this.emit({
-                  type: "status",
-                  toolName: tc.name,
-                  content: "Repeated planned file_read rejected until evidence scope changes.",
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                return { tc, output: resolvedReadBlock, success: true };
-              }
               const cohortKey = this.buildArgCohortKey(tc.name, tc.arguments);
               const cohort = this._argCohorts.get(cohortKey);
               if (cohort && cohort.failure >= 3 && cohort.success === 0) {
@@ -603161,47 +603148,6 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 adversaryRedundantSignal
               });
               let repeatShortCircuit = null;
-              const exactReadArgs = tc.arguments;
-              const exactReadPath = String(exactReadArgs?.["path"] ?? exactReadArgs?.["file"] ?? "");
-              const exactReadEvidence = exactReadEvidenceEpochs.get(toolFingerprint);
-              const exactReadEvidenceFresh = tc.name === "file_read" && exactReadPath.length > 0 && this._evidenceLedger.validateFreshness(this._normalizeEvidencePath(exactReadPath), this._absoluteToolPath(exactReadPath));
-              if (tc.name === "file_read" && exactReadEvidenceFresh && exactReadEvidence?.taskEpoch === this._taskEpoch && exactReadEvidence.mutationEpoch === fileMutationEpoch) {
-                const path16 = this._normalizeEvidencePath(exactReadPath);
-                const evidence = this._evidenceLedger.get(path16);
-                const rawCurated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
-                const curated = rawCurated?.taskEpoch === this._taskEpoch ? rawCurated : void 0;
-                const curatedPayload = curated?.output ?? (evidence?.fidelity === "extract" && evidence.content.includes("[BRANCH-EXTRACT") ? evidence.content : null);
-                repeatShortCircuit = {
-                  success: true,
-                  output: curatedPayload ? this._rehydrateResolvedReadEvidence({
-                    fingerprint: toolFingerprint,
-                    canonicalPath: path16,
-                    contentHash: curated?.contentHash ?? evidence?.contentHash ?? "unknown",
-                    payload: curatedPayload,
-                    turn
-                  }) : [
-                    ...evidence?.fidelity === "extract" ? [
-                      "[REHYDRATED_FILE_EVIDENCE]",
-                      "source=active_context_frame fidelity=extract"
-                    ] : [],
-                    "[READ EVIDENCE REFERENCE]",
-                    `path=${path16 || "unknown"}`,
-                    `task_epoch=${this._taskEpoch}`,
-                    `freshness=${evidence?.stale ? "stale" : "fresh"}`,
-                    evidence?.contentHash ? `sha256=${evidence.contentHash}` : null,
-                    "Exact unchanged range was not re-executed. Use the existing evidence handle or request a newly uncovered range after identifying the missing fact."
-                  ].filter(Boolean).join("\n"),
-                  runtimeAuthored: true,
-                  noop: true
-                };
-                this.emit({
-                  type: "status",
-                  toolName: tc.name,
-                  content: `Exact unchanged file_read blocked before dispatch: ${path16}`,
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              }
               if (criticDecision.decision === "guidance" && !repeatShortCircuit) {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
                 const _existingFp = recentToolResults.get(toolFingerprint);
@@ -603243,67 +603189,11 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 }
                 const _repeatGateMax = this._resolveRepeatGateMax();
                 const isFailedShellRepeat = this._enforcesStrictActionBoundaries() && tc.name === "shell" && typeof _existingFp?.result === "string" && _existingFp.result.includes("status: failure") && (_existingFp.mutationEpoch ?? fileMutationEpoch) === fileMutationEpoch && !this._compileFixLoopRequiresLiveShell(String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "")) && !shellLikelyMutatesFilesystem;
-                const repeatGateEligible = isReadLike || tc.name === "memory_write" || isFailedShellRepeat;
+                const repeatGateEligible = isReadLike && tc.name !== "file_read" || tc.name === "memory_write" || isFailedShellRepeat;
                 const suppressSuccessfulShellCacheGuidance = tc.name === "shell" && !isFailedShellRepeat;
                 if (suppressSuccessfulShellCacheGuidance)
                   criticGuidance = null;
-                let exactReadEvidenceFresh2 = true;
-                if (isReadLike && this._evidenceLedger) {
-                  const readArgs = tc.arguments;
-                  const readPath2 = String(readArgs?.["path"] ?? readArgs?.["file"] ?? "");
-                  if (readPath2) {
-                    const evidencePath = this._normalizeEvidencePath(readPath2);
-                    const wasFresh = evidencePath && this._evidenceLedger.validateFreshness(evidencePath, this._absoluteToolPath(readPath2));
-                    exactReadEvidenceFresh2 = Boolean(wasFresh);
-                    if (!wasFresh) {
-                      recentToolResults.delete(toolFingerprint);
-                      dedupHitCount.delete(toolFingerprint);
-                      this._recentFailures = (this._recentFailures ?? []).filter((f2) => f2.fingerprint !== toolFingerprint);
-                      repeatShortCircuit = null;
-                      this.emit({
-                        type: "status",
-                        content: `[EXTERNAL MUTATION] ${readPath2} mtime changed since last read — cache invalidated, fresh read allowed`,
-                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                      });
-                    }
-                  }
-                }
-                const exactReadEvidence2 = exactReadEvidenceEpochs.get(toolFingerprint);
-                const exactFileReadReference = tc.name === "file_read" && exactReadEvidenceFresh2 && exactReadEvidence2?.taskEpoch === this._taskEpoch && exactReadEvidence2.mutationEpoch === fileMutationEpoch;
-                if (exactFileReadReference) {
-                  const path16 = this._normalizeEvidencePath(String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? ""));
-                  const evidence = this._evidenceLedger?.get(path16);
-                  const rawCurated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
-                  const curated = rawCurated?.taskEpoch === this._taskEpoch ? rawCurated : void 0;
-                  const curatedPayload = curated?.output ?? (evidence?.fidelity === "extract" && evidence.content.includes("[BRANCH-EXTRACT") ? evidence.content : null);
-                  repeatShortCircuit = {
-                    success: true,
-                    // Curated branch output is the bounded authoritative payload
-                    // for this source version. Rehydrate it instead of replacing
-                    // it with a pointer; exact/overlap suppression must not force
-                    // the model to reread a large source merely to recover facts.
-                    output: curatedPayload ? this._rehydrateResolvedReadEvidence({
-                      fingerprint: toolFingerprint,
-                      canonicalPath: path16,
-                      contentHash: curated?.contentHash ?? evidence?.contentHash ?? "unknown",
-                      payload: curatedPayload,
-                      turn
-                    }) : [
-                      ...evidence?.fidelity === "extract" ? [
-                        "[REHYDRATED_FILE_EVIDENCE]",
-                        "source=active_context_frame fidelity=extract"
-                      ] : [],
-                      "[READ EVIDENCE REFERENCE]",
-                      `path=${path16 || "unknown"}`,
-                      `task_epoch=${this._taskEpoch}`,
-                      `freshness=${evidence?.stale ? "stale" : "fresh"}`,
-                      evidence?.contentHash ? `sha256=${evidence.contentHash}` : null,
-                      "Exact unchanged range was not re-executed. Use the existing evidence handle or request a newly uncovered range after identifying the missing fact."
-                    ].filter(Boolean).join("\n"),
-                    runtimeAuthored: true,
-                    noop: true
-                  };
-                } else if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
+                if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
                   const _rehydrateArgs = tc.arguments;
                   const _rehydratePath = String(_rehydrateArgs?.["path"] ?? _rehydrateArgs?.["file"] ?? "");
                   const _visibleViaEvidenceFrame = _rehydratePath.length > 0 && (this._evidenceLedger?.renderedFullInLastBlock(this._normalizeEvidencePath(_rehydratePath)) ?? false);
@@ -603492,7 +603382,7 @@ ${cachedResult}`,
                   tc.arguments = this._normalizeToolArgsForExecution(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
                   tc.arguments = this._autoDeriveDelegationMutationScope(resolvedTool?.name ?? tc.name, tc.arguments ?? {}, turn);
                   tc.arguments = await this._enrichDelegationToolArgs(resolvedTool?.name ?? tc.name, tc.arguments ?? {}, messages2, turn);
-                  validationError = this._partialBranchExplorationMutationBlock(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
+                  validationError = this._partialBranchExplorationMutationBlock(resolvedTool?.name ?? tc.name, tc.arguments ?? {}, turn);
                   if (!validationError)
                     validationError = this._validateFileWriteOverwriteContract(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
                 }
@@ -603633,7 +603523,9 @@ ${cachedResult}`,
                                 exactFileReadObservations.set(exactReadKey, currentRead);
                                 const canonicalPayload = this._canonicalReadEvidencePayload(currentRead.canonicalPath, currentRead.contentHash);
                                 if (canonicalPayload) {
-                                  const rehydrated = this._rehydrateResolvedReadEvidence({
+                                  const evidence = this._evidenceLedger.get(currentRead.canonicalPath);
+                                  const fullSource = evidence?.fidelity === "full" && evidence.content === canonicalPayload;
+                                  const delivered = fullSource ? canonicalPayload : this._rehydrateResolvedReadEvidence({
                                     fingerprint: exactReadKey,
                                     canonicalPath: currentRead.canonicalPath,
                                     contentHash: currentRead.contentHash,
@@ -603642,8 +603534,8 @@ ${cachedResult}`,
                                   });
                                   branchEvidenceResult = {
                                     success: true,
-                                    output: rehydrated,
-                                    llmContent: rehydrated,
+                                    output: delivered,
+                                    llmContent: delivered,
                                     beforeHash: currentRead.contentHash,
                                     runtimeAuthored: true,
                                     noop: true,
@@ -603656,44 +603548,19 @@ ${cachedResult}`,
                                   this.emit({
                                     type: "status",
                                     toolName: normalizedDispatchName,
-                                    content: `Exact unchanged file_read rehydrated: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)} fingerprint_state=resolved_from_cache`,
+                                    content: fullSource ? `Exact unchanged file_read served as canonical full source: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}` : `Exact unchanged file_read reused complete branch evidence: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}`,
                                     turn,
                                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                                   });
                                 } else {
-                                  if (this._deterministicNarrowReadFallbacks.has(exactReadKey)) {
-                                    const fallbackBlocked = [
-                                      "[REPEATED_NARROW_READ_REJECTED]",
-                                      `path=${currentRead.path}`,
-                                      "No canonical payload was produced by the allowed narrow reread. Change scope with a new range or symbol query; do not repeat identical arguments."
-                                    ].join("\n");
-                                    branchEvidenceResult = {
-                                      success: true,
-                                      output: fallbackBlocked,
-                                      llmContent: fallbackBlocked,
-                                      beforeHash: currentRead.contentHash,
-                                      runtimeAuthored: true,
-                                      noop: true
-                                    };
-                                  } else {
-                                    this._deterministicNarrowReadFallbacks.add(exactReadKey);
-                                    const previousOffset = tc.arguments["offset"];
-                                    const previousLimit = tc.arguments["limit"];
-                                    Object.assign(finalArgs, {
-                                      offset: typeof previousOffset === "number" && Number.isFinite(previousOffset) ? Math.max(1, Math.floor(previousOffset)) : 1,
-                                      limit: typeof previousLimit === "number" && Number.isFinite(previousLimit) ? Math.max(1, Math.min(160, Math.floor(previousLimit))) : 160
-                                    });
-                                    tc.arguments = finalArgs;
-                                    this._deterministicNarrowReadFallbacks.add(this._buildToolFingerprint("file_read", tc.arguments));
-                                    exactFileReadObservations.delete(exactReadKey);
-                                    this.emit({
-                                      type: "status",
-                                      toolName: normalizedDispatchName,
-                                      content: `Exact read cache lacked canonical payload; allowing one deterministic narrow reread: ${currentRead.path} offset=${tc.arguments["offset"]} limit=${tc.arguments["limit"]}`,
-                                      turn,
-                                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                                    });
-                                  }
+                                  exactFileReadObservations.delete(exactReadKey);
+                                  this.emit({
+                                    type: "status",
+                                    toolName: normalizedDispatchName,
+                                    content: `Exact read cache lacks model-visible source; executing requested read: ${currentRead.path}`,
+                                    turn,
+                                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                  });
                                 }
                               } else {
                                 exactFileReadObservations.delete(exactReadKey);
@@ -603963,7 +603830,7 @@ ${cachedResult}`,
                       fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
                       mtimeMs: this._statMtimeMsForToolPath(p2),
                       turn,
-                      fidelity: result.runtimeAuthored === true && result.output.startsWith("[BRANCH-EXTRACT") ? "extract" : void 0
+                      fidelity: result.runtimeAuthored === true && result.output.startsWith("[BRANCH-EXTRACT") ? "extract" : this._fileReadMode(tc.arguments) === "full" && this._mustHonorExplicitFullFileRead(Buffer.byteLength(result.output, "utf8"), result.output.split("\n").length, this._branchRoutingContextWindow()) ? "full" : void 0
                     });
                     if (result.runtimeAuthored !== true && this._fileReadMode(tc.arguments) !== "extract" && typeof result.beforeHash === "string") {
                       this._inlineReadArtifacts.set(tc.id, {
@@ -603983,10 +603850,6 @@ ${cachedResult}`,
                         this._inlineReadArtifacts.delete(oldest);
                       }
                     }
-                    exactReadEvidenceEpochs.set(toolFingerprint, {
-                      taskEpoch: this._taskEpoch,
-                      mutationEpoch: fileMutationEpoch
-                    });
                     this._registerReadCoverage("file_read", tc.arguments, toolFingerprint);
                   }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
@@ -607718,6 +607581,17 @@ ${marker}` : marker);
         if (toolName === "file_read") {
           const path17 = this.extractPrimaryToolPath(args);
           const evidencePath = path17 ? this._normalizeEvidencePath(path17) : "";
+          const explicitBoundedFullRead = this._fileReadMode(args ?? {}) === "full" && this._mustHonorExplicitFullFileRead(Buffer.byteLength(displayOutput, "utf8"), this.countTextLines(displayOutput), this._branchRoutingContextWindow());
+          if (explicitBoundedFullRead) {
+            return [
+              "[ADMITTED_FILE_READ v1]",
+              `path=${path17 || "unknown"}`,
+              "delivery=explicit_full_source",
+              "The requested bounded full source is present below. It may be reread after a filesystem change or when a new range is needed.",
+              "",
+              output
+            ].join("\n");
+          }
           const admitted = [...this._inlineReadArtifacts.values()].find((artifact) => artifact.path === evidencePath && output.includes(`sha256=${artifact.contentHash}`));
           if (admitted) {
             return [
@@ -607725,7 +607599,7 @@ ${marker}` : marker);
               `path=${admitted.path}`,
               `sha256=${admitted.contentHash}`,
               "delivery=full_body_once",
-              'The full selected source body below is canonical for this turn. To replace it with compact verified anchors, call file_read again with mode="extract" and purpose="the exact fact needed". Do not use shell/cat as a read workaround.',
+              'The full selected source body below is canonical for this turn. To replace it with compact verified anchors, call file_read again with mode="extract" and purpose="the exact fact needed".',
               "",
               output
             ].join("\n");
@@ -607757,7 +607631,7 @@ ${marker}` : marker);
         ].filter(Boolean).join("\n"));
       }
       shouldBypassDiscoveryCompaction(output) {
-        return output.includes("[IMAGE_BASE64:") || output.includes("[ADMITTED_FILE_READ") || /^\[BRANCH-EXTRACT(?:\s+v\d+)?\]/m.test(output) || output.includes("[REPEAT GATE - cached evidence not re-sent]") || output.includes("[REPEATED_READ_REJECTED]") || output.includes("[REPEATED_NARROW_READ_REJECTED]") || output.includes("[CACHED READ — content unchanged") || output.includes("[REHYDRATED FROM CACHE") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
+        return output.includes("[IMAGE_BASE64:") || output.includes("[ADMITTED_FILE_READ") || /^\[BRANCH-EXTRACT(?:\s+v\d+)?\]/m.test(output) || output.includes("[REPEAT GATE - cached evidence not re-sent]") || output.includes("[CACHED READ — content unchanged") || output.includes("[REHYDRATED FROM CACHE") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
       }
       countTextLines(text2) {
         if (!text2)
@@ -608193,6 +608067,8 @@ ${marker}` : marker);
       _validateFileWriteOverwriteContract(toolName, args) {
         if (toolName !== "file_write")
           return null;
+        if (!this._enforcesStrictActionBoundaries())
+          return null;
         if (process.env["OMNIUS_ALLOW_UNVERIFIED_FILE_WRITE_OVERWRITE"] === "1") {
           return null;
         }
@@ -608256,12 +608132,13 @@ ${marker}` : marker);
         return null;
       }
       /**
-       * A branch result that still has unanswered discovery requirements is an
-       * exploration state, not mutation authority.  Without this admission gate a
-       * large model could receive one attractive anchor, invent the rest, and make
-       * a broad edit before the branch's own listed recovery was attempted.
+       * Partial branch coverage is useful evidence, never mutation authority and
+       * never a tool admission gate.  The parent model may decide that its current
+       * evidence is sufficient, request more branch work, or perform a narrow edit
+       * validated by the normal file hash contract.  Blocking here caused file_edit
+       * calls to be mislabeled as stale hashes and stranded real exploration.
        */
-      _partialBranchExplorationMutationBlock(toolName, args) {
+      _partialBranchExplorationMutationBlock(toolName, args, turn) {
         const delegatedMutation = (toolName === "sub_agent" || toolName === "agent") && (args["mutation_role"] === "mutation_worker" || args["subagent_type"] === "fixer");
         if (!this._isProjectEditTool(toolName) && !delegatedMutation)
           return null;
@@ -608275,19 +608152,19 @@ ${marker}` : marker);
           if (!partial)
             continue;
           const [path16, node] = partial;
-          return [
-            "[EXPLORATION ADMISSION BLOCK]",
-            `${toolName} was not executed: ${path16} has a fresh but partial branch discovery contract.`,
-            `unresolved=${node.unresolvedRequirementIds.join(",") || "unknown"}`,
-            "The model must not make a creative/source mutation while a required file-local fact is unresolved.",
-            "Required bounded recovery:",
-            ...node.unresolvedRecoveries.length > 0 ? node.unresolvedRecoveries.map((recovery) => `- ${recovery}`) : ["- issue one narrow file_read or grep_search for the unresolved requirement"],
-            "After a complete anchored branch contract is recorded, retry the scoped mutation with fresh hash evidence."
-          ].join("\n");
+          this.emit({
+            type: "status",
+            content: `branch_discovery_partial_advisory: ${toolName} is proceeding with ${path16}; unresolved=${node.unresolvedRequirementIds.join(",") || "unknown"}; coverage is visible evidence, not an admission block`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return null;
         }
         return null;
       }
       _validateFreshExpectedHashesForEdit(toolName, args) {
+        if (!this._enforcesStrictActionBoundaries())
+          return null;
         if (process.env["OMNIUS_ALLOW_UNVERIFIED_OLD_STRING_EDIT"] === "1") {
           return null;
         }
@@ -608448,6 +608325,8 @@ ${marker}` : marker);
         ].join("\n");
       }
       editReversalPreflightBlock(toolName, args, turn) {
+        if (!this._enforcesStrictActionBoundaries())
+          return null;
         if (process.env["OMNIUS_ALLOW_BLIND_EDIT_REVERSAL"] === "1")
           return null;
         const replacements = this.extractReplacementEdits(toolName, args);
@@ -608643,6 +608522,10 @@ ${marker}` : marker);
           return this.wrapToolOutputForModel(toolName, `Error: ${result.error || "unknown error"}
 ${errOutput}`);
         }
+        const explicitBoundedFullRead = toolName === "file_read" && this._fileReadMode(args) === "full" && this._mustHonorExplicitFullFileRead(Buffer.byteLength(modelContent, "utf8"), modelContent.split("\n").length, this._branchRoutingContextWindow());
+        if (explicitBoundedFullRead) {
+          return this.wrapToolOutputForModel(toolName, modelContent);
+        }
         if (modelContent.length <= maxLen) {
           return this.wrapToolOutputForModel(toolName, modelContent);
         }
@@ -610015,10 +609898,39 @@ Describe what you see and integrate this into your current approach.` : "[User s
         const postChars = combinedSummary.length + recent.reduce((s2, m2) => s2 + _estimateMsgChars(m2), 0) + head.reduce((s2, m2) => s2 + _estimateMsgChars(m2), 0);
         const postTokens = Math.ceil(postChars / 4);
         const savedTokens = preTokens - postTokens;
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const removedMessages = messages2.slice(headEndIdx, recentStart).map((message2, offset) => {
+          const content = typeof message2.content === "string" ? message2.content : JSON.stringify(message2.content);
+          const isLegacy = this._isLegacyControlMessage(message2);
+          const isPriorSummary = message2.role === "system" && typeof message2.content === "string" && message2.content.startsWith("[Context compacted");
+          return {
+            index: headEndIdx + offset,
+            role: message2.role,
+            content,
+            chars: content.length,
+            reason: isLegacy ? "legacy_control_retired" : isPriorSummary ? "prior_summary_folded" : "history_summarized",
+            ...message2.tool_call_id ? { toolCallId: message2.tool_call_id } : {}
+          };
+        });
+        const compactionAudit = {
+          id: `cmp-${this.currentArtifactRunId()}-${Date.now().toString(36)}`,
+          runId: this.currentArtifactRunId(),
+          sessionId: this._sessionId,
+          timestamp,
+          strategy,
+          manual: force,
+          beforeTokens: preTokens,
+          afterTokens: postTokens,
+          savedTokens,
+          retainedMessages: head.length + recent.length + 1,
+          removedMessages,
+          summary: combinedSummary
+        };
         this.emit({
           type: "compaction",
-          content: `Compacted ${middle.length} messages${strategyLabel}${forceLabel}${previousSummary ? " (progressive)" : ""} | ~${preTokens.toLocaleString()} → ~${postTokens.toLocaleString()} tokens (saved ~${savedTokens.toLocaleString()})`,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          content: `Compacted ${removedMessages.length} messages${strategyLabel}${forceLabel}${previousSummary ? " (progressive)" : ""} | ~${preTokens.toLocaleString()} → ~${postTokens.toLocaleString()} tokens (saved ~${savedTokens.toLocaleString()})`,
+          timestamp,
+          compaction: compactionAudit
         });
         const tier = this.options.modelTier ?? "large";
         if (tier === "small") {
@@ -610198,6 +610110,21 @@ ${telegramPersonaHead}` : stripped
         const fileRecoveryBudget = Math.floor((this._branchRoutingContextWindow() || 32768) * 0.15);
         const maxRecoverFiles = tier === "small" ? 3 : tier === "medium" ? 4 : 5;
         const recoveredFiles = [];
+        const alreadyVisiblePaths = /* @__PURE__ */ new Set();
+        for (const message2 of result) {
+          if (typeof message2.content !== "string")
+            continue;
+          const content = message2.content;
+          const matches = [
+            ...content.matchAll(/(?:^|\n)path=([^\n]+)/g),
+            ...content.matchAll(/<recovered-(?:branch-evidence|file-reference|file) path="([^"]+)"/g)
+          ];
+          for (const match of matches) {
+            const path16 = String(match[1] ?? "").trim();
+            if (path16)
+              alreadyVisiblePaths.add(this._normalizeEvidencePath(path16));
+          }
+        }
         if (this._fileRegistry.size > 0) {
           const entries = Array.from(this._fileRegistry.entries()).sort((a2, b) => {
             if (a2[1].modified && !b[1].modified)
@@ -610208,18 +610135,36 @@ ${telegramPersonaHead}` : stripped
           }).slice(0, maxRecoverFiles);
           let recoveredTokens = 0;
           for (const [filePath, entry] of entries) {
+            const canonicalPath = this._normalizeEvidencePath(filePath);
+            if (alreadyVisiblePaths.has(canonicalPath))
+              continue;
             try {
               const { readFileSync: readFileSync144 } = await import("node:fs");
               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;
+              const smallCompleteSource = this._mustHonorExplicitFullFileRead(Buffer.byteLength(content, "utf8"), content.split("\n").length, this._branchRoutingContextWindow());
+              if (smallCompleteSource) {
+                const sourceTokens = Math.ceil(content.length / 4);
+                if (recoveredTokens + sourceTokens > fileRecoveryBudget)
+                  continue;
+                result.push({
+                  role: "system",
+                  content: `<recovered-file path="${filePath}" status="${entry.modified ? "modified" : "read"}" sha256="${_createHash("sha256").update(content).digest("hex")}" truncated="false">
+${content}
+</recovered-file>`
+                });
+                alreadyVisiblePaths.add(canonicalPath);
+                recoveredFiles.push(filePath);
+                recoveredTokens += sourceTokens;
+                continue;
+              }
               if (branchNode && // Pre-epoch in-memory nodes are same-run compatibility records;
               // retain their verified curated evidence during compaction rather
               // than falling back to a raw-file recovery reference.
-              (branchNode.taskEpoch === void 0 || branchNode.taskEpoch === this._taskEpoch) && branchNode.mtimeMs === currentMtime) {
+              (branchNode.taskEpoch === void 0 || branchNode.taskEpoch === this._taskEpoch) && branchNode.mtimeMs === currentMtime && branchNode.contractComplete) {
                 const nodeTokens = Math.ceil(branchNode.output.length / 4);
                 if (recoveredTokens + nodeTokens > fileRecoveryBudget)
                   continue;
@@ -610231,6 +610176,18 @@ ${branchNode.output}
                 });
                 recoveredFiles.push(filePath);
                 recoveredTokens += nodeTokens;
+                alreadyVisiblePaths.add(canonicalPath);
+                continue;
+              }
+              if (branchNode && !branchNode.contractComplete) {
+                const partialReference = `<recovered-file-reference path="${filePath}" status="partial-extract" sha256="${branchNode.contentHash}">A prior isolated extraction was partial; it is advisory only. Request full source or a new targeted range if this file is now needed.</recovered-file-reference>`;
+                const referenceTokens = Math.ceil(partialReference.length / 4);
+                if (recoveredTokens + referenceTokens > fileRecoveryBudget)
+                  continue;
+                result.push({ role: "system", content: partialReference });
+                alreadyVisiblePaths.add(canonicalPath);
+                recoveredFiles.push(filePath);
+                recoveredTokens += referenceTokens;
                 continue;
               }
               const recoveryDecision = assessBranchRead({
@@ -610247,6 +610204,7 @@ ${branchNode.output}
                 const referenceTokens = Math.ceil(reference.length / 4);
                 if (recoveredTokens + referenceTokens <= fileRecoveryBudget) {
                   result.push({ role: "system", content: reference });
+                  alreadyVisiblePaths.add(canonicalPath);
                   recoveredFiles.push(filePath);
                   recoveredTokens += referenceTokens;
                 }
@@ -644372,6 +644330,7 @@ var init_ollama_gpu_policy = __esm({
 var omnius_directory_exports = {};
 __export(omnius_directory_exports, {
   OMNIUS_DIR: () => OMNIUS_DIR,
+  appendCompactionAudit: () => appendCompactionAudit,
   buildContextRestorePrompt: () => buildContextRestorePrompt,
   buildContextRestoreSnapshot: () => buildContextRestoreSnapshot,
   buildHandoffPrompt: () => buildHandoffPrompt,
@@ -645076,6 +645035,32 @@ function pruneContextLedger(ledgerPath) {
   } catch {
   }
 }
+function appendCompactionAudit(repoRoot, record) {
+  try {
+    const contextDir = join136(repoRoot, OMNIUS_DIR, "context");
+    mkdirSync76(contextDir, { recursive: true });
+    const ledgerPath = join136(contextDir, COMPACTION_AUDIT_FILE);
+    appendFileSync14(ledgerPath, JSON.stringify(record) + "\n", "utf-8");
+    const st = statSync51(ledgerPath);
+    if (st.size > 64 * 1024 * 1024) {
+      const lines = readFileSync102(ledgerPath, "utf-8").split(/\r?\n/).filter((line) => line.trim());
+      if (lines.length > 100) {
+        const archiveDir = join136(contextDir, "archive");
+        mkdirSync76(archiveDir, { recursive: true });
+        const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        writeFileSync64(
+          join136(archiveDir, `compactions.${stamp}.jsonl`),
+          lines.slice(0, -100).join("\n") + "\n",
+          "utf-8"
+        );
+        writeFileSync64(ledgerPath, lines.slice(-100).join("\n") + "\n", "utf-8");
+      }
+    }
+    return ledgerPath;
+  } catch {
+    return null;
+  }
+}
 function saveSessionContext(repoRoot, entry) {
   const contextDir = join136(repoRoot, OMNIUS_DIR, "context");
   mkdirSync76(contextDir, { recursive: true });
@@ -646032,7 +646017,7 @@ function deleteUsageRecord(kind, value2, repoRoot) {
     remove(join136(repoRoot, OMNIUS_DIR, USAGE_HISTORY_FILE));
   }
 }
-var OMNIUS_DIR, LEGACY_DIRS, SUBDIRS, gitignoreWatchers, gitignoreRetryTimers, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, MAX_SESSION_DIARY_DETAILED_ENTRIES, MAX_CONTEXT_LEDGER_LINES, MAX_CONTEXT_LEDGER_BYTES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, MODEL_CONTEXT_NOISE_LINE_RE, DEFAULT_RESTORED_SESSION_HISTORY_MAX_LINES, DEICTIC_CONTINUATION_TERMS, SESSIONS_DIR, SESSIONS_INDEX, TUI_STATE_SUFFIX, AUTHORED_SESSION_LINE, VISUAL_CHROME_LINE, SKIP_DIRS3, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
+var OMNIUS_DIR, LEGACY_DIRS, SUBDIRS, gitignoreWatchers, gitignoreRetryTimers, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, COMPACTION_AUDIT_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, MAX_SESSION_DIARY_DETAILED_ENTRIES, MAX_CONTEXT_LEDGER_LINES, MAX_CONTEXT_LEDGER_BYTES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, MODEL_CONTEXT_NOISE_LINE_RE, DEFAULT_RESTORED_SESSION_HISTORY_MAX_LINES, DEICTIC_CONTINUATION_TERMS, SESSIONS_DIR, SESSIONS_INDEX, TUI_STATE_SUFFIX, AUTHORED_SESSION_LINE, VISUAL_CHROME_LINE, SKIP_DIRS3, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
 var init_omnius_directory = __esm({
   "packages/cli/src/tui/omnius-directory.ts"() {
     init_dist5();
@@ -646056,6 +646041,7 @@ var init_omnius_directory = __esm({
     HANDOFF_FILE = "task-handoff.json";
     CONTEXT_SAVE_FILE = "session-context.json";
     CONTEXT_LEDGER_FILE = "session-context.events.jsonl";
+    COMPACTION_AUDIT_FILE = "compactions.jsonl";
     MAX_CONTEXT_ENTRIES = 200;
     MAX_SESSION_DIARY_ENTRIES = 80;
     MAX_SESSION_DIARY_DETAILED_ENTRIES = 50;
@@ -664897,6 +664883,7 @@ __export(daemon_exports, {
   ensureDaemonVersion: () => ensureDaemonVersion,
   forceKillDaemon: () => forceKillDaemon,
   getDaemonPid: () => getDaemonPid,
+  getDaemonReportedIdentity: () => getDaemonReportedIdentity,
   getDaemonReportedVersion: () => getDaemonReportedVersion,
   getDaemonStatus: () => getDaemonStatus,
   getLocalCliVersion: () => getLocalCliVersion,
@@ -665048,17 +665035,26 @@ function getLocalCliVersion() {
   }
   return "0.0.0";
 }
-async function getDaemonReportedVersion(port) {
+async function getDaemonReportedIdentity(port) {
   const p2 = port ?? getDaemonPort();
   try {
     const resp = await fetch(`http://127.0.0.1:${p2}/health`, { signal: AbortSignal.timeout(2e3) });
     if (!resp.ok) return null;
     const data = await resp.json();
-    return data.version ?? null;
+    const version5 = data.boot_version ?? data.version;
+    if (!version5) return null;
+    return {
+      version: version5,
+      bootVersion: data.boot_version ?? version5,
+      bootPackageHash: data.boot_package_hash ?? null
+    };
   } catch {
     return null;
   }
 }
+async function getDaemonReportedVersion(port) {
+  return (await getDaemonReportedIdentity(port))?.bootVersion ?? null;
+}
 async function waitForDaemonReady(port, expectedVersion, attempts = 24) {
   let observedVersion = null;
   for (let attempt = 0; attempt < attempts; attempt++) {
@@ -665112,6 +665108,8 @@ async function repairManagedDaemonUnit(port) {
       `Description=Omnius API Daemon (port ${port})`,
       "After=network-online.target",
       "Wants=network-online.target",
+      "StartLimitIntervalSec=30",
+      "StartLimitBurst=10",
       "",
       "[Service]",
       "Type=simple",
@@ -665121,8 +665119,6 @@ async function repairManagedDaemonUnit(port) {
       `ExecStart=${execStart}`,
       "Restart=always",
       "RestartSec=3",
-      "StartLimitIntervalSec=30",
-      "StartLimitBurst=10",
       `StandardOutput=append:${join149(logDir, "daemon.log")}`,
       `StandardError=append:${join149(logDir, "daemon.err.log")}`,
       "",
@@ -665450,13 +665446,14 @@ async function recoverDaemonVersionBoundedly(expectedVersion, observe, recover,
   return { ok: false, observedVersion, attempts: boundedAttempts };
 }
 async function ensureDaemonVersion(expectedVersion = getLocalCliVersion(), port = getDaemonPort()) {
-  const finish = (ok3, action, observedVersion, recoveryAttempts = 0) => ({
+  const finish = (ok3, action, observedVersion, recoveryAttempts = 0, requiresPrivilegedMigration = false) => ({
     ok: ok3,
     action,
     expectedVersion,
     observedVersion,
     port,
-    recoveryAttempts
+    recoveryAttempts,
+    requiresPrivilegedMigration
   });
   if (await isDaemonRunning(port)) {
     if (process.env["OMNIUS_NO_VERSION_GUARD"] !== "1") {
@@ -665471,7 +665468,8 @@ async function ensureDaemonVersion(expectedVersion = getLocalCliVersion(), port
           recovery.ok,
           recovery.ok ? "restarted" : "failed",
           recovery.observedVersion,
-          recovery.attempts
+          recovery.attempts,
+          !recovery.ok && process.platform === "linux"
         );
       }
     }
@@ -673385,52 +673383,83 @@ async function acquireSudoCredentials(ctx3, reason) {
     });
   });
 }
+async function runSudoScriptChecked(ctx3, script) {
+  const { spawn: spawn40 } = await import("node:child_process");
+  const full = `set -e; ${script}`;
+  await withTransientTerminalPrivilegePrompt(
+    ctx3,
+    "Running elevated system changes.",
+    () => new Promise((resolve82, reject) => {
+      const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
+      const hasInteractiveTty = Boolean(
+        process.stdin.isTTY && process.stdout.isTTY
+      );
+      const cmd = isRoot ? "bash" : "sudo";
+      const args = isRoot ? ["-lc", full] : hasInteractiveTty ? ["bash", "-lc", full] : ["-n", "bash", "-lc", full];
+      const child = spawn40(cmd, args, {
+        stdio: hasInteractiveTty ? "inherit" : ["ignore", "pipe", "pipe"],
+        env: { ...process.env, DEBIAN_FRONTEND: "noninteractive" }
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      onChildExit(child, (code8) => {
+        if (code8 === 0) {
+          resolve82();
+          return;
+        }
+        reject(
+          new Error(
+            (stderr || stdout || `elevated command exited with ${code8}`).trim().slice(0, 500)
+          )
+        );
+      });
+      onChildError(child, (err) => reject(err));
+    })
+  );
+}
 async function runSudoScript(ctx3, script) {
   try {
-    const { spawn: spawn40 } = await import("node:child_process");
-    const full = `set -e; ${script}`;
-    await withTransientTerminalPrivilegePrompt(
-      ctx3,
-      "Running elevated system changes.",
-      () => new Promise((resolve82, reject) => {
-        const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
-        const hasInteractiveTty = Boolean(
-          process.stdin.isTTY && process.stdout.isTTY
-        );
-        const cmd = isRoot ? "bash" : "sudo";
-        const args = isRoot ? ["-lc", full] : hasInteractiveTty ? ["bash", "-lc", full] : ["-n", "bash", "-lc", full];
-        const child = spawn40(cmd, args, {
-          stdio: hasInteractiveTty ? "inherit" : ["ignore", "pipe", "pipe"],
-          env: { ...process.env, DEBIAN_FRONTEND: "noninteractive" }
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout?.on("data", (data) => {
-          stdout += data.toString();
-        });
-        child.stderr?.on("data", (data) => {
-          stderr += data.toString();
-        });
-        onChildExit(child, (code8) => {
-          if (code8 === 0) {
-            resolve82();
-            return;
-          }
-          reject(
-            new Error(
-              (stderr || stdout || `elevated command exited with ${code8}`).trim().slice(0, 500)
-            )
-          );
-        });
-        onChildError(child, (err) => reject(err));
-      })
-    );
+    await runSudoScriptChecked(ctx3, script);
   } catch (err) {
     renderWarning(
       `Elevated command failed: ${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
+async function migrateAttestedPrivilegedDaemonOwner(ctx3, port) {
+  if (process.platform !== "linux" || !Number.isInteger(port) || port <= 0) {
+    return false;
+  }
+  const script = [
+    "set -euo pipefail",
+    `port=${port}`,
+    "found=0",
+    "for pid in $( { lsof -nP -t -iTCP:${port} -sTCP:LISTEN 2>/dev/null || true; fuser ${port}/tcp 2>/dev/null || true; } | tr ' ' '\\n' | sort -un); do",
+    "  [ -r /proc/$pid/cmdline ] || continue",
+    "  cmd=$(tr '\\000' ' ' </proc/$pid/cmdline)",
+    '  case "$cmd" in *omnius*serve*--daemon*) ;; *) continue ;; esac',
+    "  unit=$(sed -nE 's#.*(/[^:]*\\.service).*#\\1#p' /proc/$pid/cgroup | head -n1 | sed 's#.*/##')",
+    '  [ "$unit" = power-monitor.service ] || continue',
+    '  echo "Migrating attested Omnius daemon owner: $unit (pid $pid)"',
+    '  systemctl restart "$unit"',
+    "  found=1",
+    "  break",
+    "done",
+    '[ "$found" = 1 ]'
+  ].join("\n");
+  try {
+    await runSudoScriptChecked(ctx3, script);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function ensureVoiceDeps(ctx3) {
   try {
     const mod3 = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
@@ -689147,13 +689176,29 @@ async function handleUpdate(subcommand, ctx3) {
   installOverlay.setStatus("Gracefully upgrading shared daemon...");
   const { ensureDaemonVersion: ensureDaemonVersion2, getLocalCliVersion: getLocalCliVersion2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
   const expectedDaemonVersion = getLocalCliVersion2();
-  const daemonUpgrade = await ensureDaemonVersion2(expectedDaemonVersion);
+  let daemonUpgrade = await ensureDaemonVersion2(expectedDaemonVersion);
+  if (!daemonUpgrade.ok && daemonUpgrade.requiresPrivilegedMigration) {
+    installOverlay.stop("Migrating the verified privileged daemon owner...");
+    await new Promise((r2) => setTimeout(r2, 300));
+    installOverlay.dismiss();
+    const migrated = await migrateAttestedPrivilegedDaemonOwner(
+      ctx3,
+      daemonUpgrade.port
+    );
+    if (migrated) {
+      const migrationOverlay = startInstallOverlay(targetVersion);
+      Object.assign(installOverlay, migrationOverlay);
+      installOverlay.setPhase("Daemon");
+      installOverlay.setStatus("Verifying the migrated daemon...");
+      daemonUpgrade = await ensureDaemonVersion2(expectedDaemonVersion);
+    }
+  }
   if (!daemonUpgrade.ok) {
     installOverlay.stop("Update installed, but daemon upgrade was not verified");
     await new Promise((r2) => setTimeout(r2, 1200));
     installOverlay.dismiss();
     renderError(
-      `Updated CLI to ${expectedDaemonVersion}, but automatic daemon recovery exhausted ${daemonUpgrade.recoveryAttempts} verified restart round(s) and the shared daemon still reports ${daemonUpgrade.observedVersion ?? "unavailable"}. The TUI remains open. Run /daemon status and inspect ~/.omnius/daemon.err.log; the service may be blocked outside Omnius.`
+      `Updated CLI to ${expectedDaemonVersion}, but the shared daemon still reports ${daemonUpgrade.observedVersion ?? "unavailable"} after ${daemonUpgrade.recoveryAttempts} verified recovery round(s). A privileged owner was ${daemonUpgrade.requiresPrivilegedMigration ? "not safely migratable" : "not detected"}; no arbitrary port holder was terminated.`
     );
     return;
   }
@@ -745062,6 +745107,7 @@ var init_embedding_workers = __esm({
 var serve_exports = {};
 __export(serve_exports, {
   apiServeCommand: () => apiServeCommand,
+  readServerPackageIdentity: () => readServerPackageIdentity,
   startApiServer: () => startApiServer
 });
 import * as http5 from "node:http";
@@ -745086,8 +745132,7 @@ import {
   readSync as readSync4,
   closeSync as closeSync8
 } from "node:fs";
-import { randomBytes as randomBytes29, randomUUID as randomUUID21, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { createHash as createHash52 } from "node:crypto";
+import { createHash as createHash52, randomBytes as randomBytes29, randomUUID as randomUUID21, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join183(baseDir, ".omnius");
   return {
@@ -745096,7 +745141,7 @@ function memoryDbPaths3(baseDir = process.cwd()) {
     knowledge: join183(dir, "knowledge.db")
   };
 }
-function getVersion3() {
+function readServerPackageIdentity() {
   try {
     const thisDir = dirname56(fileURLToPath23(import.meta.url));
     const candidates = [
@@ -745107,9 +745152,14 @@ function getVersion3() {
     for (const pkgPath of candidates) {
       try {
         if (!existsSync173(pkgPath)) continue;
-        const pkg = JSON.parse(readFileSync140(pkgPath, "utf8"));
+        const raw = readFileSync140(pkgPath, "utf8");
+        const pkg = JSON.parse(raw);
         if (pkg.name === "omnius" || pkg.name === "@omnius/cli" || pkg.name === "@omnius/monorepo") {
-          return pkg.version ?? "0.0.0";
+          return {
+            version: pkg.version ?? "0.0.0",
+            packagePath: pkgPath,
+            packageHash: createHash52("sha256").update(raw).digest("hex")
+          };
         }
       } catch {
         continue;
@@ -745117,7 +745167,10 @@ function getVersion3() {
     }
   } catch {
   }
-  return "0.0.0";
+  return { version: "0.0.0", packagePath: null, packageHash: null };
+}
+function getVersion3() {
+  return SERVER_BOOT_IDENTITY.version;
 }
 function normalizeLocalhostForDaemon(url) {
   if (process.env["OMNIUS_KEEP_LOCALHOST"] === "1") return url;
@@ -746923,7 +746976,12 @@ function handleHealth(res) {
   jsonResponse(res, 200, {
     status: "ok",
     uptime_s: Math.floor((Date.now() - startedAt) / 1e3),
-    version: version5
+    version: version5,
+    // `version` is retained for old clients. These explicit boot fields let
+    // an updater prove that the process, rather than only its install path,
+    // changed after an npm swap.
+    boot_version: SERVER_BOOT_IDENTITY.version,
+    boot_package_hash: SERVER_BOOT_IDENTITY.packageHash
   });
 }
 async function handleHealthReady(res, ollamaUrl) {
@@ -746956,6 +747014,8 @@ function handleVersion(res) {
   const version5 = getVersion3();
   jsonResponse(res, 200, {
     version: version5,
+    boot_version: SERVER_BOOT_IDENTITY.version,
+    boot_package_hash: SERVER_BOOT_IDENTITY.packageHash,
     node: process.version,
     platform: process.platform
   });
@@ -754485,27 +754545,11 @@ function startApiServer(options2 = {}) {
   omnius API server v${version5}
 `);
     if (process.env["OMNIUS_DAEMON"] === "1" && process.env["OMNIUS_NO_VERSION_GUARD"] !== "1") {
-      const readDiskVersion = () => {
-        try {
-          const here = dirname56(fileURLToPath23(import.meta.url));
-          for (const rel of ["../package.json", "../../package.json", "../../../package.json", "../../../../package.json"]) {
-            const p2 = join183(here, rel);
-            if (existsSync173(p2)) {
-              const pkg = JSON.parse(readFileSync140(p2, "utf8"));
-              if (pkg.name === "omnius" || pkg.name === "@omnius/cli" || pkg.name === "@omnius/monorepo") {
-                return pkg.version ?? null;
-              }
-            }
-          }
-        } catch {
-        }
-        return null;
-      };
-      const bootVersion = readDiskVersion() ?? version5;
+      const bootIdentity = SERVER_BOOT_IDENTITY;
       const versionWatch = setInterval(() => {
-        const disk = readDiskVersion();
-        if (disk && disk !== bootVersion) {
-          log22(`  [daemon] version changed on disk ${bootVersion} -> ${disk}; restarting for the new version…
+        const disk = readServerPackageIdentity();
+        if (disk.version !== bootIdentity.version || disk.packageHash && disk.packageHash !== bootIdentity.packageHash) {
+          log22(`  [daemon] package identity changed on disk ${bootIdentity.version} -> ${disk.version}; restarting for the new version…
 `);
           try {
             server2.close(() => process.exit(0));
@@ -755387,7 +755431,7 @@ function setTimerEnabled(name10, enabled2) {
     return false;
   }
 }
-var require4, NEXUS_DIRECTORY_ORIGIN2, NEXUS_SPONSORS_URL2, endpointRegistry, modelRouteMap, endpointUsage, _lastEndpointDiagnostics, BACKEND_TIMEOUT_DEFAULT_MS, BACKEND_TIMEOUT_MAX_MS, MODEL_LIST_TIMEOUT_DEFAULT_MS, metrics, startedAt, FILE_MIME_BY_EXT, realtimeOllamaFallbackCache, runningProcesses, LOCAL_UI_SESSION_COOKIE, LOCAL_UI_SESSION_TOKEN, perKeyUsage, CRON_MARKER2;
+var require4, NEXUS_DIRECTORY_ORIGIN2, NEXUS_SPONSORS_URL2, SERVER_BOOT_IDENTITY, endpointRegistry, modelRouteMap, endpointUsage, _lastEndpointDiagnostics, BACKEND_TIMEOUT_DEFAULT_MS, BACKEND_TIMEOUT_MAX_MS, MODEL_LIST_TIMEOUT_DEFAULT_MS, metrics, startedAt, FILE_MIME_BY_EXT, realtimeOllamaFallbackCache, runningProcesses, LOCAL_UI_SESSION_COOKIE, LOCAL_UI_SESSION_TOKEN, perKeyUsage, CRON_MARKER2;
 var init_serve = __esm({
   "packages/cli/src/api/serve.ts"() {
     init_config();
@@ -755424,6 +755468,7 @@ var init_serve = __esm({
     require4 = createRequire8(import.meta.url);
     NEXUS_DIRECTORY_ORIGIN2 = (process.env["OMNIUS_NEXUS_DIRECTORY_ORIGIN"] || process.env["OMNIUS_NEXUS_SIGNALING_SERVER"] || "https://openagents.nexus").replace(/\/+$/, "");
     NEXUS_SPONSORS_URL2 = `${NEXUS_DIRECTORY_ORIGIN2}/api/v1/sponsors`;
+    SERVER_BOOT_IDENTITY = readServerPackageIdentity();
     endpointRegistry = [];
     modelRouteMap = /* @__PURE__ */ new Map();
     endpointUsage = /* @__PURE__ */ new Map();
@@ -756584,6 +756629,57 @@ function appendSubAgentNoteBox(statusBar, agentId, event, title, metrics2, conte
     spec
   );
 }
+function prepareCompactionAudit(event) {
+  const record = event.compaction;
+  if (!record) {
+    return {
+      display: event.content ?? "Context compacted (legacy event without an audit payload).",
+      ledger: {
+        schemaVersion: 1,
+        timestamp: event.timestamp,
+        legacy: true,
+        summary: event.content ?? "",
+        removedMessages: []
+      }
+    };
+  }
+  const redactor = getSecretRedactor();
+  const removedMessages = record.removedMessages.map((message2) => ({
+    ...message2,
+    content: redactor.redactText(message2.content)
+  }));
+  const summary = redactor.redactText(record.summary);
+  const lines = [
+    "[COMPACTION AUDIT]",
+    `id=${record.id}`,
+    `reason=context budget; strategy=${record.strategy}${record.manual ? "; manual" : ""}`,
+    `tokens=~${record.beforeTokens.toLocaleString()} → ~${record.afterTokens.toLocaleString()} (saved ~${record.savedTokens.toLocaleString()})`,
+    `removed=${removedMessages.length}; retained=${record.retainedMessages}`,
+    "ledger=.omnius/context/compactions.jsonl",
+    "",
+    "Summary retained for the model:",
+    summary || "(none)",
+    "",
+    `Exact removed model-visible messages (${removedMessages.length}):`
+  ];
+  for (const message2 of removedMessages) {
+    lines.push(
+      `--- removed[${message2.index}] role=${message2.role} chars=${message2.chars} reason=${message2.reason}${message2.toolCallId ? ` tool_call_id=${message2.toolCallId}` : ""} ---`,
+      message2.content || "(empty)"
+    );
+  }
+  return {
+    display: lines.join("\n"),
+    ledger: {
+      schemaVersion: 1,
+      ...record,
+      summary,
+      removedMessages,
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "interactive-tui"
+    }
+  };
+}
 function writeSubAgentEventForView(statusBar, agentId, event, verbose = false) {
   const previewLine = formatSubAgentEventForView(event);
   statusBar.updateAgentViewEvent(agentId, event, previewLine ?? event.type);
@@ -759336,11 +759432,18 @@ ${entry.fullContent}`
         statusBar?.updateTrajectoryCheckpoint(event.trajectory ?? null);
         break;
       case "compaction":
+        const compactionAudit = prepareCompactionAudit(event);
+        appendCompactionAudit(process.cwd(), compactionAudit.ledger);
         if (isNeovimActive()) {
-          writeToNeovimOutput("\x1B[33m⚠ Context compacted\x1B[0m\r\n");
+          writeToNeovimOutput("\x1B[33m⚠ Context compacted — audit: .omnius/context/compactions.jsonl\x1B[0m\r\n");
         } else {
           contentWrite(
-            () => renderWarning(`Context compacted: ${event.content}`)
+            () => renderToolResult(
+              "context_compaction",
+              true,
+              compactionAudit.display,
+              { verbose: config.verbose }
+            )
           );
         }
         if (onCompaction) onCompaction();