@cortexkit/opencode-magic-context 0.49.5 → 0.49.7

package/dist/{index-x3y1np1h.js → index-tagss15p.js}

@@ -38,7 +38,7 @@ import {
   SqliteAcquisitionBusyError2,
   withAsyncPrivilegedWriter2,
   indexCoordinationInput2
-} from "./index-kb9nn0a0.js";
+} from "./index-j8epsc0g.js";
 import {
   shouldSkipHomeProjectMemory,
   ProjectIdentityError,
@@ -53,7 +53,7 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./index-41gqa557.js";
+} from "./index-g8qbdb03.js";
 import {
   recordSessionProjectIdentity,
   hasRecordedSessionProjectIdentity,
@@ -80,7 +80,7 @@ import {
   drainCommitBacklogForProject2,
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2
-} from "./index-c0b01zrc.js";
+} from "./index-sf94at64.js";
 import {
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
@@ -110,6 +110,7 @@ import {
 import {
   protectedToolTokenCount,
   peelLeadingMcTagNotation,
+  isThinkingPart,
   isRecord,
   contentTagOwnerMessageId,
   normalizeTodoStateJson,
@@ -142,9 +143,10 @@ import {
   getDroppedTagsByNumbers2,
   getMaxDroppedTagNumber2,
   getTagById2
-} from "./index-yqps2zsv.js";
+} from "./index-tmtty2x5.js";
 import {
-  observeTemporalDecisions
+  observeTemporalDecisions,
+  stableStringify
 } from "./index-1bt88epp.js";
 import {
   withContentLanguageDirective,
@@ -164,7 +166,7 @@ import {
   extractInMemoryMessageViews2,
   buildInMemoryTailRawMessages2,
   runSessionWarmupWorker
-} from "./index-jpm52v9x.js";
+} from "./index-37q80veb.js";
 import {
   openCodeDbExists,
   withReadOnlySessionDb,
@@ -172,10 +174,11 @@ import {
   latestPersistedMessageForRecovery,
   latestRealUserTurnIdFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-qvr78ej6.js";
+} from "./index-a8acx4gc.js";
 import {
   expandToolPart,
   estimateTrueRawMessageTokens,
+  isTextPart,
   toolPartHasUserAnswer,
   DreamTokenBudgetExceeded,
   isEditTool,
@@ -185,6 +188,8 @@ import {
   sessionDecisionCalibration,
   getProtectionWindowForSession,
   ensureSessionMetaRow,
+  withReplayEnvelopeSnapshot,
+  invalidateReplayEnvelopeSnapshot,
   isRustMarkerAdmissionFenced,
   setRustMarkerAdmissionFence,
   readReplayEnvelope,
@@ -268,11 +273,16 @@ import {
   createFinalWireUsageTracker,
   estimateFinalWireInputTokens,
   estimateAppendedWireTokens,
+  partHasCompletedResult,
+  extractToolCallObservation,
+  ToolMutationBatch,
+  createToolDropTarget,
   setRawMessageProvider2,
   cleanUserText2,
   withRawSessionMessageCache2,
   readRawSessionMessages2,
   visitRawSessionMessages2,
+  visitRawSessionMessagesAsync2,
   prepareRawSessionOrdinals2,
   primeTailRawMessageCache2,
   primeInMemoryTailRawMessageCache2,
@@ -284,7 +294,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./index-7zg9dvx0.js";
+} from "./index-n5a170gs.js";
 import {
   getMeasuredToolDefinitionTokens
 } from "./index-h2wc01qk.js";
@@ -315,20 +325,20 @@ import {
   runSqliteOptimize,
   openDatabase,
   openCurrentDatabase
-} from "./index-znzgze2v.js";
+} from "./index-4btknbqh.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
   rpcPortFilePath,
   parseRpcPortFile,
   inspectProcessesAsync
-} from "./index-6m7rdv7y.js";
+} from "./index-w4mw92w3.js";
 import {
   configureContextDatabasePragmas2
 } from "./index-fb3zxn06.js";
 import {
   canonicalProjectDirectory
-} from "./index-7w18gg78.js";
+} from "./index-rzmjkdd6.js";
 import {
   unescapeXml,
   resolveWorkspaceShareCategories,
@@ -337,7 +347,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./index-xfbfrngb.js";
+} from "./index-j5hce1ab.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -394,6 +404,8 @@ import {
   resolveLkgModelKeys,
   createLkgEntryProjector,
   captureLkgSlot,
+  validateAnthropicReasoningRuns,
+  validateLkgSeam,
   replayLkg,
   coldStartRawServedIndex,
   coldStartUncapturedReplay,
@@ -509,7 +521,7 @@ import {
   snapRangeToCompartments,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-v4bqjy56.js";
+} from "./index-5tbvdff4.js";
 import {
   SubcClient,
   connectionFileExists,
@@ -538,7 +550,7 @@ import {
   indexSingleMessage2,
   indexMessagesAfterOrdinal2,
   sweepOrphanedOpenCodeMessageIndexes2
-} from "./index-3wckxwfp.js";
+} from "./index-wq16ahsn.js";
 import {
   renderUserFacingFailure,
   userFacingFailureCode,
@@ -582,7 +594,7 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./index-fjtgekd4.js";
+} from "./index-n7kwfw2r.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -600,7 +612,7 @@ import {
 } from "./index-4dhv7mqz.js";
 import {
   cosineSimilarity
-} from "./index-7ndnvw7a.js";
+} from "./index-w6bd03dc.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -625,7 +637,7 @@ import {
   mergeMemoryStats2,
   archiveMemory2,
   getMemoryCountsByStatus2
-} from "./index-7jzrrxap.js";
+} from "./index-9yyqq3mm.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -641,23 +653,25 @@ import {
   SubcModuleTransport,
   indexCommitsForProject,
   embedUnembeddedCommits,
+  withMessageFtsSessionFilter,
   createUnifiedSearchDiagnostics2,
   parseIdShapedQuery2,
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./index-fst3t0d9.js";
+} from "./index-j58gqrn2.js";
 import {
   flushIgnoredMessages2,
   clearIgnoredMessages2,
   observeIgnoredNotificationEvent2,
   sendStatusNotification2
-} from "./index-bhk710rw.js";
+} from "./index-vt4sf4ep.js";
 import {
   setRecompStarting2,
   setRecompTerminal2
-} from "./index-dd18gej8.js";
+} from "./index-rwmpkss5.js";
 import {
+  makeToolCompositeKey,
   searchMessageHistoryOffThread,
   findSessionId,
   findLastUserMessageId,
@@ -706,7 +720,7 @@ import {
   abortSessionFailClosed2,
   evaluateEmergencyFailClosed2,
   runPostTransformPhase2
-} from "./index-2mqps3c1.js";
+} from "./index-ebnngykq.js";
 import {
   ANNOUNCEMENT_VERSION2,
   ANNOUNCEMENT_FEATURES2,
@@ -2797,6 +2811,25 @@ async function runHiddenSingleShotPrompt(args) {
     });
     promptSettled = true;
     return { validated: run.validated, completion: run.output, childSessionId: handle.id };
+  } catch (error) {
+    if (args.onFailureOutput) {
+      let timer;
+      try {
+        const completion = await Promise.race([
+          args.executor.collect(handle, 200),
+          new Promise((resolve) => {
+            timer = setTimeout(() => resolve(null), 5000);
+          })
+        ]);
+        if (completion)
+          args.onFailureOutput(completion);
+      } catch (readError) {
+        log2(`${args.callContext}: failed to collect interrupted output: ${String(readError)}`);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw error;
   } finally {
     await args.executor.close(handle, {
       promptSettled,
@@ -6626,31 +6659,33 @@ function snapshotMaintainDocsFiles(docsDir) {
 import { createHash as createHash5 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
+import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync4, statSync } from "node:fs";
 import path3 from "node:path";
+import { promisify as promisify2 } from "node:util";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
 A memory's BACKING FILES are the file(s) whose code the memory makes a claim about — the files you would open to check whether the memory is accurate. You do NOT judge accuracy, rewrite, or remove anything. You only LOCATE backing files.
 
-Tools (read-only): read, grep, glob. Request line ranges rather than full files; use offset/limit for longer files. Each memory may come with "Likely files" already named in it and confirmed to exist — confirm those FIRST (cheap) instead of searching. Use search/grep to FIND code only when no likely files are given. Do not guess — confirm a file exists and genuinely backs the memory before listing it. Keep reads minimal: you do not need to read a whole file to confirm it backs a one-line claim.
+Tools (read-only): read, grep, glob. Use at most 3 tool calls per memory, including searches and reads. Never read the same file twice in a batch; reuse what you already learned. Never repeat an identical search or use broad searches such as "fn " or ".*". Request one useful line range, not repeated slices. Each memory may come with "Likely files" from paths it names or a literal identifier search, confirmed to exist — confirm those FIRST (cheap) instead of searching. Use search/grep to FIND code only when no likely files are given. Do not guess — confirm a file exists and genuinely backs the memory before listing it. You are locating code, not exhaustively verifying the claim. If the call budget runs out before you can decide, leave that id unmapped and move on; uncertainty is not evidence of file-independence.
 
 For each memory decide ONE of:
-- Backing files found → the COMPLETE set of repo-relative paths whose code the memory is about.
+- Backing files found → the specific repo-relative paths whose code the memory is about; do not chase every caller or related implementation.
 - File-independent → the memory describes EXTERNAL behavior (a provider / API / platform / protocol limit, e.g. "Anthropic returns 400 on empty content"), or a pure process / workflow / philosophy rule, with NO specific local file that backs it. A BEHAVIORAL claim (when to act, how to work, who decides, or tool-usage discipline) is file-independent even when it cites file paths or commands as examples: a named file is not the file backing the rule.
 
-Output ONE XML manifest at the very end and NOTHING else — no narration, no per-memory commentary, no reasoning:
+Output ONE XML manifest and NOTHING else — no narration, no per-memory commentary, no reasoning. Open <mappings> before investigating. Emit each <memory> element as soon as you decide its mapping, before investigating the next memory, so an interruption cannot lose completed work. Close </mappings> when finished:
 <mappings>
 <memory id="N" files="path/a.ts,path/b.ts"/>
 <memory id="M" independent="true"/>
 </mappings>
 
 Rules:
-- Every input memory id MUST appear exactly once.
+- Every decided input memory id MUST appear exactly once. Omit uncertain ids rather than inventing backing files or declaring them independent.
 - files: repo-relative, comma-separated, no spaces inside a path. Only files that actually exist and genuinely back the memory.
 - A BACKING FILE is CODE that implements or handles the claim — not a file that merely mentions it. A path named inside a process directive is an action target or example, not evidence that the file backs the directive. A markdown doc (.md), a PARITY/notes file, or a test that only DESCRIBES an external fact is NOT a backing file. If the only place a memory's fact appears is prose/docs/a test (no code implements or handles it), mark it independent="true".
 - Many CONSTRAINTS are HYBRID: "external system does X, and OUR code handles it here." Map those to the HANDLING code (you can verify the handling, even though you can't verify the external behavior). Only mark independent when there is NO local code that implements or handles the fact.
 - Prefer the most specific file(s); do not pad with tangential files. Most memories map to one file; some to a few.
-- When you genuinely cannot find any local backing and it is not clearly external, still emit the memory with independent="true" (do not drop it).`;
+- Mark independent="true" only for the file-independent cases above; an investigation that runs out of calls stays unmapped.`;
 var MAX_SEED_PATHS_PER_MEMORY = 3;
 var PATH_PATTERN = "`?((?:[\\w.-]+\\/)+[\\w.-]+\\.(?:ts|tsx|js|jsx|mjs|cjs|rs|go|py|json|jsonc|sql|toml|sh))`?";
 function extractMemoryCandidatePaths(content, repoDir) {
@@ -6672,10 +6707,65 @@ function extractMemoryCandidatePaths(content, repoDir) {
   }
   return [...found];
 }
+var execFileAsync2 = promisify2(execFile2);
+async function seedIdentifierCandidates(memories, repoDir) {
+  const identifiers = new Map(memories.filter((memory) => memory.candidates.length === 0).map((memory) => [
+    memory.id,
+    [
+      ...new Set(memory.content.match(/\b(?:[A-Z][A-Za-z0-9_]{3,}|[a-z][a-z0-9]*[A-Z][A-Za-z0-9_]*|[a-z][a-z0-9]*_[A-Za-z0-9_]{2,})\b/g) ?? [])
+    ].slice(0, 3)
+  ]));
+  const terms = [...new Set([...identifiers.values()].flat())];
+  if (terms.length === 0)
+    return memories;
+  let stdout;
+  try {
+    const result = await execFileAsync2("git", [
+      "-c",
+      "core.quotePath=false",
+      "grep",
+      "--no-color",
+      "-n",
+      "-I",
+      "-F",
+      ...terms.flatMap((term) => ["-e", term]),
+      "--",
+      ...["ts", "tsx", "js", "jsx", "mjs", "cjs", "rs", "go", "py", "sql", "sh"].map((extension) => `*.${extension}`)
+    ], {
+      cwd: repoDir,
+      encoding: "utf8",
+      timeout: 2000,
+      maxBuffer: 256 * 1024,
+      windowsHide: true,
+      killSignal: "SIGKILL"
+    });
+    stdout = result.stdout;
+  } catch {
+    return memories;
+  }
+  const matches = stdout.split(`
+`).flatMap((line) => {
+    const match = line.match(/^([^:]+):\d+:(.*)$/);
+    return match ? [{ file: match[1], text: match[2] }] : [];
+  });
+  return memories.map((memory) => {
+    const names = identifiers.get(memory.id);
+    if (!names?.length)
+      return memory;
+    const files = new Map;
+    for (const match of matches) {
+      const score = names.filter((name) => match.text.includes(name)).length;
+      if (score)
+        files.set(match.file, Math.max(files.get(match.file) ?? 0, score));
+    }
+    const candidates = [...files].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_SEED_PATHS_PER_MEMORY).map(([file]) => file);
+    return candidates.length ? { ...memory, candidates } : memory;
+  });
+}
 function buildMapMemoriesPrompt(projectPath, memories) {
   const list = memories.map((m) => {
     const seed = m.candidates.length ? `
-Likely files (named in the memory, confirmed to exist): ${m.candidates.join(", ")}` : "";
+Likely files (candidate paths, confirmed to exist): ${m.candidates.join(", ")}` : "";
     return `[${m.id}] ${m.category}
 ${m.content}${seed}`;
   }).join(`
@@ -6685,13 +6775,13 @@ ${m.content}${seed}`;
 
 Project: ${projectPath}
 
-For each memory below, find the repo file(s) it makes a claim about, or mark it file-independent. Behavioral process/workflow directives stay file-independent even when they name files. When "Likely files" are listed, those paths are named in the memory and confirmed to exist — START there only for code claims: confirm each actually backs the claim (a quick read/outline), drop any that don't, add others only if genuinely needed. Search from scratch only when no likely files are given. Then output ONE <mappings> manifest covering every id.
+For each memory below, find the repo file(s) it makes a claim about, or mark it file-independent. Behavioral process/workflow directives stay file-independent even when they name files. When "Likely files" are listed, those paths either occur in the memory or match its identifiers in a bounded literal source search — START there only for code claims: confirm each actually backs the claim (a quick read/outline), drop any that don't, add others only if genuinely needed. Search from scratch only when no likely files are given. Use at most 3 tool calls per memory, reuse prior reads, and emit each decided mapping immediately in ONE <mappings> manifest. Leave uncertain ids unmapped and move on.
 
 <memories>
 ${list}
 </memories>`;
 }
-var MEMORY_ELEMENT_PATTERN = "<memory\\b([^>]*)(?:\\/>|>([\\s\\S]*?)<\\/memory>)";
+var MEMORY_ELEMENT_PATTERN = "<memory\\b([^<>]*)(?:\\/>|>([\\s\\S]*?)<\\/memory>)";
 var NESTED_FILE_PATTERN = "<file\\b([^>]*)\\/?>";
 function extractNestedFilePaths(inner) {
   const files = [];
@@ -6749,12 +6839,78 @@ function validateMapMemoriesManifest(text, expectedIds) {
   assertNoDuplicateManifestIds(parsed.filter((entry) => expectedIds.has(entry.id)).map((entry) => entry.id), "mappings");
   return parsed;
 }
+function parsePartialMapMemoriesManifest(text, expectedIds) {
+  const start = text.indexOf("<mappings>");
+  if (start < 0)
+    return [];
+  const entries = new Map;
+  const conflicts = new Set;
+  for (const match of text.slice(start).matchAll(new RegExp(MEMORY_ELEMENT_PATTERN, "gi"))) {
+    try {
+      const entry = parseMapMemoriesManifest(`<mappings>${match[0]}</mappings>`)[0];
+      if (!entry || !expectedIds.has(entry.id) || conflicts.has(entry.id))
+        continue;
+      const previous = entries.get(entry.id);
+      if (previous && JSON.stringify(previous) !== JSON.stringify(entry)) {
+        entries.delete(entry.id);
+        conflicts.add(entry.id);
+      } else {
+        entries.set(entry.id, entry);
+      }
+    } catch {}
+  }
+  return [...entries.values()];
+}
 
 // src/features/magic-context/dreamer/map-memories.ts
-var MAP_BATCH_SIZE = 20;
+var MAP_BATCH_SIZE = 5;
 var MAP_BATCH_FLOOR_MS = 240000;
 var CONSECUTIVE_TIMEOUT_LIMIT2 = 2;
 var MAX_INDEPENDENT_REQUEUE_PER_RUN = MAP_BATCH_SIZE;
+function retryKey(project) {
+  return `map-memories:retry:${project}`;
+}
+function readRetries(db, project) {
+  try {
+    const parsed = JSON.parse(getDreamState(db, retryKey(project)) ?? "{}");
+    if (!isRecord(parsed))
+      return {};
+    const retries = {};
+    for (const [id, value] of Object.entries(parsed)) {
+      if (isRecord(value) && typeof value.content === "string" && typeof value.failures === "number" && typeof value.deferUntil === "number") {
+        retries[id] = {
+          content: value.content,
+          failures: value.failures,
+          deferUntil: value.deferUntil
+        };
+      }
+    }
+    return retries;
+  } catch {
+    return {};
+  }
+}
+function contentKey(memory) {
+  return createHash5("sha256").update(`${memory.category}
+${memory.content}`).digest("hex");
+}
+function isDeferred(memory, retries) {
+  const retry = retries[memory.id];
+  return !!retry && retry.content === contentKey(memory) && retry.deferUntil > Date.now();
+}
+function assistantText(messages) {
+  return messages.filter((message) => isRecord(message) && (message.role === "assistant" || isRecord(message.info) && message.info.role === "assistant")).map((message) => extractLatestAssistantText([message]) ?? (isRecord(message) && Array.isArray(message.content) ? message.content.filter(isRecord).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+`) : "")).join(`
+`);
+}
+function currentManifest(text) {
+  const start = text.lastIndexOf("<mappings>");
+  return start < 0 ? text : text.slice(start);
+}
+function logBatchUsage(messages, committed, startedAt) {
+  const steps = messages.filter((message) => isRecord(message) && (message.role === "assistant" || isRecord(message.info) && message.info.role === "assistant")).length;
+  log2(`[dreamer] map-memories batch: steps=${steps} committed=${committed} steps_per_memory=${committed ? (steps / committed).toFixed(2) : "n/a"} elapsed_ms=${Date.now() - startedAt}`);
+}
 function computeMapBatchSliceMs(remainingMs, batchesRemaining) {
   return Math.min(remainingMs, Math.max(MAP_BATCH_FLOOR_MS, Math.floor(remainingMs / batchesRemaining)));
 }
@@ -6776,7 +6932,7 @@ function toMapInput(memory, repoDir) {
     candidates: extractMemoryCandidatePaths(memory.content, repoDir)
   };
 }
-function selectMapMemoryInputs(db, projectIdentity, repoDir) {
+function selectMapMemoryInputs(db, projectIdentity, repoDir, includeDeferred = false) {
   const active = getMemoriesByProject2(db, projectIdentity);
   const activeIds = active.map((m) => m.id);
   const unmapped = new Set(getUnmappedMemoryIds(db, activeIds));
@@ -6795,7 +6951,8 @@ function selectMapMemoryInputs(db, projectIdentity, repoDir) {
     if (requeue.length >= MAX_INDEPENDENT_REQUEUE_PER_RUN)
       break;
   }
-  return [...unmappedInputs, ...requeue];
+  const retries = readRetries(db, projectIdentity);
+  return [...unmappedInputs, ...requeue].filter((memory) => includeDeferred || !isDeferred(memory, retries));
 }
 async function mapMemories(args) {
   const result = {
@@ -6805,14 +6962,21 @@ async function mapMemories(args) {
     remaining: 0,
     complete: true
   };
-  const inputs = selectMapMemoryInputs(args.db, args.projectIdentity, args.sessionDirectory);
+  const allInputs = selectMapMemoryInputs(args.db, args.projectIdentity, args.sessionDirectory, true);
+  const retries = readRetries(args.db, args.projectIdentity);
+  const activeIds = new Set(allInputs.map((memory) => String(memory.id)));
+  for (const id of Object.keys(retries))
+    if (!activeIds.has(id))
+      delete retries[id];
+  const inputs = allInputs.filter((memory) => !isDeferred(memory, retries));
+  result.remaining = allInputs.length;
+  result.complete = result.remaining === 0;
   if (inputs.length === 0)
     return result;
   const batches = [];
   for (let i = 0;i < inputs.length; i += MAP_BATCH_SIZE) {
     batches.push({ inputs: inputs.slice(i, i + MAP_BATCH_SIZE), isOmissionRetry: false });
   }
-  result.remaining = inputs.length;
   const abortController = new AbortController;
   const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, (reason) => abortController.abort(new Error(reason)), args.leaseAcquisition);
   try {
@@ -6835,6 +6999,24 @@ async function mapMemories(args) {
         break;
       const outcome = await mapOneBatch(args, batch.inputs, sliceMs, abortController.signal);
       const committed = outcome.mapped + outcome.independent;
+      runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+        const committedIds = new Set(outcome.committedIds);
+        for (const memory of batch.inputs) {
+          if (committedIds.has(memory.id)) {
+            delete retries[memory.id];
+            continue;
+          }
+          const content = contentKey(memory);
+          const prior = retries[memory.id];
+          const failures = (prior?.content === content ? prior.failures : 0) + 1;
+          retries[memory.id] = {
+            content,
+            failures,
+            deferUntil: failures < 2 ? 0 : Date.now() + Math.min(24, 2 ** (failures - 2)) * 3600000
+          };
+        }
+        setDreamState(args.db, retryKey(args.projectIdentity), JSON.stringify(retries));
+      });
       result.mapped += outcome.mapped;
       result.independent += outcome.independent;
       result.remaining -= committed;
@@ -6844,8 +7026,8 @@ async function mapMemories(args) {
       }
       if (outcome.requeue?.length) {
         if (!batch.isOmissionRetry) {
-          batches.splice(i + 1, 0, {
-            inputs: outcome.requeue,
+          batches.push({
+            inputs: outcome.requeue.filter((memory) => !isDeferred(memory, retries)),
             isOmissionRetry: true
           });
           log2(`[dreamer] map-memories: committed ${committed}/${batch.inputs.length} mapping(s); requeueing ${outcome.requeue.length} omitted id(s) in a targeted retry`);
@@ -6853,12 +7035,12 @@ async function mapMemories(args) {
           log2(`[dreamer] map-memories: targeted retry still omitted ${outcome.requeue.length} id(s); leaving them unmapped for the next run`);
         }
       }
-      if (outcome.failure?.class === "timeout") {
+      if (outcome.failure?.class === "timeout" && committed === 0) {
         consecutiveTimeouts += 1;
         timeoutStreakElapsedMs.push(outcome.failure.elapsedMs);
         if (consecutiveTimeouts >= CONSECUTIVE_TIMEOUT_LIMIT2) {
           result.stopReason = "timeout-circuit-breaker";
-          log2(`[dreamer] map-memories starvation: circuit breaker tripped after ${consecutiveTimeouts} consecutive batch timeouts (model too slow for its time slice); per-batch elapsed [${timeoutStreakElapsedMs.join("ms, ")}ms] vs ${sliceMs}ms slice; stopping with ${result.remaining} mapping(s) remaining`);
+          log2(`[dreamer] map-memories starvation: circuit breaker tripped after ${consecutiveTimeouts} consecutive batch timeouts with no committed mappings (investigation made no durable progress); per-batch elapsed [${timeoutStreakElapsedMs.join("ms, ")}ms] vs ${sliceMs}ms slice; stopping with ${result.remaining} mapping(s) remaining`);
           break;
         }
       } else {
@@ -6878,12 +7060,13 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
   let promptSettled = false;
   const startedAt = Date.now();
   let budgetFinalized = false;
+  let failedCompletion;
   const onBudgetUpdate = (state) => {
     budgetFinalized ||= state.finalizeFired;
     args.onBudgetUpdate?.(state);
   };
   try {
-    const prompt = buildMapMemoriesPrompt(args.projectIdentity, batch);
+    const prompt = buildMapMemoriesPrompt(args.projectIdentity, await seedIdentifierCandidates(batch, args.sessionDirectory));
     if (args.hiddenCompletionExecutor) {
       const run = await runHiddenSingleShotPrompt({
         executor: args.hiddenCompletionExecutor,
@@ -6899,14 +7082,18 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         fallbackModels: args.fallbackModels,
         timeoutMs: sliceMs,
         signal,
-        parse: (text) => validateMapMemoriesManifest(text, new Set(batch.map((memory) => memory.id)))
+        onFailureOutput: (completion) => {
+          failedCompletion = completion;
+        },
+        parse: (text, completion) => validateMapMemoriesManifest(currentManifest(assistantText(completion.messages ?? []) || text), new Set(batch.map((memory) => memory.id)))
       });
       recordInvocation2(args, startedAt, {
         status: "completed",
         messages: run.completion.messages ?? []
       });
-      const outcome = await applyParsedBatchMappings(args, batch, run.validated, budgetFinalized);
-      const returnedIds = new Set(run.validated.map((entry) => entry.id));
+      const outcome = await applyParsedBatchMappings(args, batch, run.validated, budgetFinalized, true);
+      logBatchUsage(run.completion.messages ?? [], outcome.mapped + outcome.independent, startedAt);
+      const returnedIds = new Set(outcome.committedIds);
       return {
         ...outcome,
         requeue: budgetFinalized ? [] : batch.filter((memory) => !returnedIds.has(memory.id))
@@ -6949,7 +7136,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
       fetchOutput: async () => {
         const messagesResponse = await client.session.messages({
           path: { id: agentSessionId },
-          query: { directory: args.sessionDirectory, limit: 100 }
+          query: { directory: args.sessionDirectory, limit: 200 }
         });
         return normalizeSDKResponse(messagesResponse, [], {
           preferResponseOnMissingData: true
@@ -6959,7 +7146,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         if (hasLengthCappedOutput(messages)) {
           throw new Error("map-memories returned length-capped output");
         }
-        const text = extractLatestAssistantText(messages);
+        const text = currentManifest(assistantText(messages));
         if (!text)
           throw new Error("map-memories returned no output");
         return validateMapMemoriesManifest(text, new Set(batch.map((memory) => memory.id)));
@@ -6967,8 +7154,9 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
     });
     promptSettled = true;
     recordInvocation2(args, startedAt, { status: "completed", messages: run.output });
-    const outcome = await applyParsedBatchMappings(args, batch, run.validated, budgetFinalized);
-    const returnedIds = new Set(run.validated.filter((entry) => batch.some((memory) => memory.id === entry.id)).map((entry) => entry.id));
+    const outcome = await applyParsedBatchMappings(args, batch, run.validated, budgetFinalized, true);
+    logBatchUsage(run.output, outcome.mapped + outcome.independent, startedAt);
+    const returnedIds = new Set(outcome.committedIds);
     return {
       ...outcome,
       requeue: budgetFinalized ? [] : batch.filter((memory) => !returnedIds.has(memory.id))
@@ -6976,18 +7164,23 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
   } catch (error) {
     const desc = describeError(error);
     log2(`[dreamer] map-memories batch failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
+    const messages = failedCompletion?.messages ?? await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory) ?? [];
     recordInvocation2(args, startedAt, {
       status: failedInvocationStatus(error),
       error,
-      messages: await readFailedChildMessages(args.client, agentSessionId, args.sessionDirectory)
+      messages
     });
-    if (error instanceof DreamerModuleFailureError || error instanceof DreamTokenBudgetExceeded)
+    if (error instanceof DreamerModuleFailureError)
       throw error;
     if (signal.aborted)
       throw error;
+    const recovered = parsePartialMapMemoriesManifest(assistantText(messages) || failedCompletion?.text || "", new Set(batch.map((memory) => memory.id)));
+    const outcome = await applyParsedBatchMappings(args, batch, recovered, budgetFinalized, true);
+    logBatchUsage(messages, outcome.mapped + outcome.independent, startedAt);
+    if (error instanceof DreamTokenBudgetExceeded)
+      throw error;
     return {
-      mapped: 0,
-      independent: 0,
+      ...outcome,
       failure: {
         class: isTimeoutClassError2(error) ? "timeout" : "other",
         elapsedMs: Date.now() - startedAt
@@ -7006,7 +7199,7 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
       });
   }
 }
-async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = false) {
+async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = false, allowPartial = false) {
   const batchIds = new Set(batch.map((memory) => memory.id));
   const valid = parsed.filter((entry) => batchIds.has(entry.id));
   const unknown = parsed.filter((entry) => !batchIds.has(entry.id));
@@ -7014,14 +7207,14 @@ async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = f
     log2(`[dreamer] map-memories warning: dropping ${unknown.length} unknown mapping entr${unknown.length === 1 ? "y" : "ies"} outside the current batch (${unknown.map((entry) => entry.id).join(", ")})`);
   }
   assertNoDuplicateManifestIds(valid.map((entry) => entry.id), "mappings");
-  if (!budgetFinalized && valid.length * 2 < batch.length) {
+  if (!allowPartial && !budgetFinalized && valid.length * 2 < batch.length) {
     throw new Error(`mappings manifest covers ${valid.length}/${batch.length} batch ids after filtering unknown entries; rejecting mostly-wrong manifest`);
   }
   if (budgetFinalized && valid.length < batch.length) {
     log2(`[dreamer] map-memories: accepted partial manifest after token budget: ${valid.length}/${batch.length}`);
   }
   if (valid.length === 0)
-    return { mapped: 0, independent: 0 };
+    return { mapped: 0, independent: 0, committedIds: [] };
   const planned = [];
   const batchById = new Map(batch.map((memory) => [memory.id, memory]));
   for (const p of valid) {
@@ -7070,9 +7263,10 @@ async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = f
     });
   }
   if (planned.length === 0)
-    return { mapped: 0, independent: 0 };
+    return { mapped: 0, independent: 0, committedIds: [] };
   let mapped = 0;
   let independent = 0;
+  const committedIds = [];
   if (args.moduleRoute) {
     const identities = getModuleMemoryIdentities(args.db, args.projectIdentity, planned.map((item) => item.id));
     const rows = planned.map((item) => {
@@ -7110,19 +7304,22 @@ async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = f
     const accepted = new Set(result.accepted.filter((id) => typeof id === "number"));
     for (const item of planned) {
       const identity = identities.get(item.id);
-      if (identity && accepted.has(identity.moduleId))
+      if (identity && accepted.has(identity.moduleId)) {
         item.independent ? independent += 1 : mapped += 1;
+        committedIds.push(item.id);
+      }
     }
-    return { mapped, independent };
+    return { mapped, independent, committedIds };
   }
   const now = Date.now();
   runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
     for (const item of planned) {
       recordMemoryMapping(args.db, item.id, item.files, now, item.mappingOrigin);
       item.independent ? independent += 1 : mapped += 1;
+      committedIds.push(item.id);
     }
   });
-  return { mapped, independent };
+  return { mapped, independent, committedIds };
 }
 function recordInvocation2(args, startedAt, params) {
   if (!args.parentSessionId)
@@ -7390,32 +7587,41 @@ async function promotePrimers(args) {
 // src/features/magic-context/dreamer/primer-seed.ts
 var PRIMER_SEED_CAP_TOKENS = 4000;
 function renderUserAndToolOrientation(sessionId, startOrdinal, endOrdinal, capTokens) {
+  const renderer = orientationRenderer(capTokens);
+  visitRawSessionMessages2(sessionId, startOrdinal, endOrdinal, renderer.visit, {
+    summary: true
+  });
+  return renderer.result();
+}
+function orientationRenderer(capTokens) {
   const lines = [];
   let tokens = 0;
   let sawMessage = false;
-  visitRawSessionMessages2(sessionId, startOrdinal, endOrdinal, (msg) => {
-    sawMessage = true;
-    const out = [];
-    if (msg.role === "user" && hasMeaningfulUserText2(msg.parts)) {
-      const text = extractTexts2(msg.parts).map((t) => cleanUserText2(t)).map(normalizeText).filter((t) => t.length > 0).join(" / ");
-      if (text)
-        out.push(`U: ${text}`);
-    }
-    for (const tc of extractToolCallSummaries(msg.parts))
-      out.push(tc);
-    for (const line of out) {
-      const lineTokens = estimateTokens(line);
-      if (tokens + lineTokens > capTokens && lines.length > 0) {
-        lines.push("… (orientation truncated; investigate the current source directly)");
-        return false;
+  return {
+    visit: (msg) => {
+      sawMessage = true;
+      const out = [];
+      if (msg.role === "user" && hasMeaningfulUserText2(msg.parts)) {
+        const text = extractTexts2(msg.parts).map((t) => cleanUserText2(t)).map(normalizeText).filter((t) => t.length > 0).join(" / ");
+        if (text)
+          out.push(`U: ${text}`);
+      }
+      for (const tc of extractToolCallSummaries(msg.parts))
+        out.push(tc);
+      for (const line of out) {
+        const lineTokens = estimateTokens(line);
+        if (tokens + lineTokens > capTokens && lines.length > 0) {
+          lines.push("… (orientation truncated; investigate the current source directly)");
+          return false;
+        }
+        lines.push(line);
+        tokens += lineTokens;
       }
-      lines.push(line);
-      tokens += lineTokens;
-    }
-    return true;
-  }, { summary: true });
-  return sawMessage ? lines.join(`
-`) : null;
+      return true;
+    },
+    result: () => sawMessage ? lines.join(`
+`) : null
+  };
 }
 function selectPrimerOriginCandidate(db, primer) {
   return getPrimerCandidatesByIds(db, primer.sourceCandidateIds).filter((candidate) => candidate.projectPath === primer.projectPath).sort((a, b) => b.sourceMessageTime - a.sourceMessageTime || b.id - a.id)[0];
@@ -7449,16 +7655,37 @@ function closedBookOriginP1(db, sessionId, originStartMessage) {
   return { orientation, sessionId };
 }
 function buildPrimerSeed(db, primer) {
+  return buildPrimerSeedUsing(db, selectPrimerOriginCandidate(db, primer), renderUserAndToolOrientation);
+}
+async function buildPrimerSeedAsync(db, primer) {
   const mostRecent = selectPrimerOriginCandidate(db, primer);
+  let orientation = null;
+  if (mostRecent && typeof mostRecent.sourceCompartmentStart === "number" && typeof mostRecent.sourceCompartmentEnd === "number") {
+    try {
+      const renderer = orientationRenderer(PRIMER_SEED_CAP_TOKENS);
+      await visitRawSessionMessagesAsync2(mostRecent.sessionId, mostRecent.sourceCompartmentStart, mostRecent.sourceCompartmentEnd, renderer.visit, { summary: true });
+      orientation = renderer.result();
+    } catch {
+      orientation = null;
+    }
+  }
+  return buildPrimerSeedUsing(db, mostRecent, () => orientation);
+}
+function buildPrimerSeedUsing(db, mostRecent, render) {
   if (!mostRecent || typeof mostRecent.sourceCompartmentStart !== "number" || typeof mostRecent.sourceCompartmentEnd !== "number") {
-    return { kind: "closed-book", orientation: "", prePost: "", sessionId: null };
+    return {
+      kind: "closed-book",
+      orientation: "",
+      prePost: "",
+      sessionId: null
+    };
   }
   const sessionId = mostRecent.sessionId;
   const start = mostRecent.sourceCompartmentStart;
   const end = mostRecent.sourceCompartmentEnd;
   let orientation = null;
   try {
-    orientation = renderUserAndToolOrientation(sessionId, start, end, PRIMER_SEED_CAP_TOKENS);
+    orientation = render(sessionId, start, end, PRIMER_SEED_CAP_TOKENS);
   } catch {
     orientation = null;
   }
@@ -7589,14 +7816,14 @@ async function refreshOnePrimer(args, primer, sliceMs, signal) {
       provider = null;
     }
   }
-  const seed = withRawSessionMessageCache2(() => {
+  const seed = await (async () => {
     const unregister = provider && originSessionId ? setRawMessageProvider2(originSessionId, provider) : null;
     try {
-      return buildPrimerSeed(args.db, primer);
+      return provider?.iterateMessageRangeAsync ? await buildPrimerSeedAsync(args.db, primer) : withRawSessionMessageCache2(() => buildPrimerSeed(args.db, primer));
     } finally {
       unregister?.();
     }
-  });
+  })();
   let agentSessionId = null;
   let promptSettled = false;
   const startedAt = Date.now();
@@ -7612,7 +7839,10 @@ async function refreshOnePrimer(args, primer, sliceMs, signal) {
         prompt,
         title: "magic-context-dream-refresh-primers",
         callContext: "dreamer:refresh-primers",
-        metadata: { tokenBudget: args.tokenBudget, onBudgetUpdate: args.onBudgetUpdate },
+        metadata: {
+          tokenBudget: args.tokenBudget,
+          onBudgetUpdate: args.onBudgetUpdate
+        },
         model: args.model,
         fallbackModels: args.fallbackModels,
         language: args.language,
@@ -7678,7 +7908,10 @@ async function refreshOnePrimer(args, primer, sliceMs, signal) {
       validateOutput: (messages) => parseAnswer(messages, primer.answer)
     });
     promptSettled = true;
-    recordInvocation3(args, startedAt, { status: "completed", messages: run.output });
+    recordInvocation3(args, startedAt, {
+      status: "completed",
+      messages: run.output
+    });
     const answer = run.validated.trim();
     if (!answer)
       return false;
@@ -7693,7 +7926,10 @@ async function refreshOnePrimer(args, primer, sliceMs, signal) {
   } catch (error) {
     const desc = describeError(error);
     log2(`[dreamer] refresh-primers failed (primer #${primer.id}): ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
-    recordInvocation3(args, startedAt, { status: failedInvocationStatus(error), error });
+    recordInvocation3(args, startedAt, {
+      status: failedInvocationStatus(error),
+      error
+    });
     throw error;
   } finally {
     if (agentSessionId && args.client)
@@ -8210,9 +8446,9 @@ function evaluateTaskGate(task, ctx) {
 import { createHash as createHash6 } from "node:crypto";
 
 // src/features/magic-context/dreamer/verify-diff.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var exec = promisify2(execFile2);
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var exec = promisify3(execFile3);
 var VERIFY_DIFF_BUDGET_TOKENS = 12000;
 var MAX_DIFF_BYTES = 4 * 1024 * 1024;
 async function git2(root, args) {
@@ -15706,8 +15942,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-xw9wt5bm.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-yp9m5g4p.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-trcgmm23.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-2tp44tfa.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -15776,7 +16012,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-z7agncp8.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-df61jmz9.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -16215,11 +16451,11 @@ function clone(value) {
     return value;
   return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
 }
-function isThinkingPart(part) {
+function isThinkingPart2(part) {
   return isRecord(part) && ["thinking", "reasoning", "redacted_thinking"].includes(String(part.type));
 }
 function replayableOriginal(part) {
-  if (!isThinkingPart(part) || !isRecord(part))
+  if (!isThinkingPart2(part) || !isRecord(part))
     return false;
   const metadata = isRecord(part.metadata) && isRecord(part.metadata.anthropic) ? part.metadata.anthropic : {};
   const signature = part.signature ?? part.thinkingSignature ?? metadata.signature ?? part.data ?? metadata.redactedData;
@@ -16527,7 +16763,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash11, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID6 } from "node:crypto";
 
 // src/features/magic-context/memory/single-store-embedding-drain.ts
 function isWatermarkRow(row) {
@@ -19059,13 +19295,235 @@ function resolveRustLkgReplayParticipant(sessionId) {
     return latest;
   return alive.length === 1 ? alive[0] : undefined;
 }
-function noteExternalLkgReplay(participant, sessionId, inputCount) {
+function noteExternalLkgReplay(participant, sessionId, inputMessages, servedMessages) {
   if (!participant)
     return;
-  participant.enterFreezeFromExternalServe(sessionId, inputCount);
+  participant.enterFreezeFromExternalServe(sessionId, inputMessages, servedMessages);
   sessionLog2(sessionId, "lkg_external_replay_froze_rust_adapter");
 }
 
+// src/hooks/magic-context/rust-served-raw.ts
+import { createHash as createHash11 } from "node:crypto";
+class RustServedRawConflict extends EmergencyFailClosedError {
+  reason;
+  messageIds;
+  firstBlockId;
+  constructor(reason, messageIds, firstBlockId) {
+    super(`Rust served-raw conflict: ${reason} at ${firstBlockId}`);
+    this.reason = reason;
+    this.messageIds = messageIds;
+    this.firstBlockId = firstBlockId;
+  }
+}
+function partDigest(part) {
+  const serialized = JSON.stringify(part);
+  return createHash11("sha256").update(stableStringify(serialized === undefined ? undefined : JSON.parse(serialized))).digest("hex");
+}
+function records(doc) {
+  if (doc.rustServedRaw === undefined)
+    return [];
+  if (!Array.isArray(doc.rustServedRaw))
+    throw new EmergencyFailClosedError("Invalid Rust served-raw evidence");
+  for (const row of doc.rustServedRaw) {
+    if (!row || typeof row.messageId !== "string" || !Number.isSafeInteger(row.index) || row.index < 0 || row.partId !== undefined && typeof row.partId !== "string" || typeof row.digest !== "string" || !/^[a-f0-9]{64}$/.test(row.digest) || !Array.isArray(row.blockIds) || !row.blockIds.every((id) => typeof id === "string")) {
+      throw new EmergencyFailClosedError("Invalid Rust served-raw part");
+    }
+  }
+  return doc.rustServedRaw;
+}
+function rustRawRebuild(db, sessionId) {
+  const value = readReplayEnvelope(db, sessionId).rustRawRebuild;
+  if (value === undefined)
+    return;
+  if (!value || typeof value.identity !== "string" || !/^[a-f0-9]{64}$/.test(value.identity) || !["source_removed", "source_changed", "candidate_loss", "candidate_conflict"].includes(value.reason) || !Array.isArray(value.messageIds) || !value.messageIds.every((id) => typeof id === "string") || typeof value.firstBlockId !== "string" || typeof value.pending !== "boolean") {
+    throw new EmergencyFailClosedError("Invalid Rust raw-rebuild request");
+  }
+  return value;
+}
+function servedRawBlockIds(db, sessionId) {
+  return records(readReplayEnvelope(db, sessionId)).flatMap((row) => row.blockIds);
+}
+function sourcePart(row, message) {
+  return row.partId === undefined ? message?.parts[row.index] : message?.parts.find((part) => part?.id === row.partId);
+}
+function conflict(row, reason) {
+  return new RustServedRawConflict(reason, [row.messageId], row.blockIds[0] ?? `${row.messageId}#0`);
+}
+function checkRustServedRawIngress(db, sessionId, input) {
+  const rows = records(readReplayEnvelope(db, sessionId));
+  if (!rows.length)
+    return;
+  const byId = new Map(input.map((message) => [message.info.id, message]));
+  const changed = rows.filter((row) => partDigest(sourcePart(row, byId.get(row.messageId))) !== row.digest);
+  const first = changed[0];
+  if (!first)
+    return;
+  throw new RustServedRawConflict(sourcePart(first, byId.get(first.messageId)) === undefined ? "source_removed" : "source_changed", [...new Set(changed.map((row) => row.messageId))], first.blockIds[0] ?? `${first.messageId}#0`);
+}
+function requestRustRawRebuild(db, sessionId, error) {
+  if (!updateReplayDocument(db, sessionId, (doc) => {
+    const previous = doc.rustRawRebuild;
+    if (previous?.pending && previous.reason === error.reason && previous.firstBlockId === error.firstBlockId && error.messageIds.every((id) => previous.messageIds.includes(id)))
+      return false;
+    const messageIds = [
+      ...new Set([
+        ...previous?.pending ? previous.messageIds : [],
+        ...error.messageIds
+      ])
+    ];
+    const identity = partDigest([
+      previous?.identity ?? "",
+      error.reason,
+      messageIds,
+      error.firstBlockId
+    ]);
+    doc.version = 2;
+    doc.rustRawRebuild = {
+      identity,
+      reason: error.reason,
+      messageIds,
+      firstBlockId: error.firstBlockId,
+      pending: true
+    };
+    return true;
+  }))
+    throw new EmergencyFailClosedError("Cannot persist Rust raw-rebuild request");
+}
+function noteRustServedRaw(db, sessionId, input, served) {
+  const additions = [];
+  const byId = new Map(served.filter((message) => typeof message?.info?.id === "string").map((message) => [message.info.id, message]));
+  for (const message of input) {
+    const visible = byId.get(message.info.id);
+    if (!visible)
+      continue;
+    let offset = 0;
+    for (const [index, value] of message.parts.entries()) {
+      if (!value || typeof value !== "object")
+        continue;
+      const part = value;
+      const count = encodeOpenCodeMessagesToCk([{ ...message, parts: [part] }])[0].ck.content.length;
+      const actual = typeof part.id === "string" ? visible.parts.find((candidate) => candidate?.id === part.id) : visible.parts[index];
+      const status = part.state?.status;
+      const reachesProvider = !(part.type === "text" && part.ignored === true) && ![
+        "compaction",
+        "step-start",
+        "step-finish",
+        "snapshot",
+        "patch",
+        "agent",
+        "retry"
+      ].includes(String(part.type)) && (part.type !== "tool" || status === "completed" || status === "error");
+      if (reachesProvider && count > 0) {
+        const digest = partDigest(part);
+        if (actual === part || partDigest(actual) === digest) {
+          additions.push({
+            messageId: message.info.id,
+            index,
+            ...typeof part.id === "string" ? { partId: part.id } : {},
+            digest,
+            blockIds: Array.from({ length: count }, (_, i) => `${message.info.id}#${offset + i}`)
+          });
+        }
+      }
+      offset += count;
+    }
+  }
+  if (!additions.length)
+    return;
+  if (!updateReplayDocument(db, sessionId, (doc) => {
+    const rows = records(doc);
+    const key = (row) => stableStringify([row.messageId, row.partId ?? row.index]);
+    const merged = new Map(rows.map((row) => [key(row), row]));
+    for (const row of additions)
+      merged.set(key(row), row);
+    const next = [...merged.values()];
+    if (stableStringify(rows) === stableStringify(next))
+      return false;
+    doc.version = 2;
+    doc.rustServedRaw = next;
+    return true;
+  }))
+    throw new EmergencyFailClosedError("Cannot persist Rust served-raw evidence");
+}
+function preserveRustServedRaw(db, sessionId, output, input = output, reconstruct = new Set, covered = new Set) {
+  const rows = records(readReplayEnvelope(db, sessionId));
+  if (!rows.length)
+    return false;
+  const sources = new Map(input.map((message) => [message.info.id, message]));
+  const byId = new Map(output.map((message) => [message.info.id, message]));
+  let repaired = false;
+  for (const row of rows) {
+    if (covered.has(row.messageId))
+      continue;
+    const original = sources.get(row.messageId);
+    const source = sourcePart(row, original);
+    if (!original || !source)
+      throw conflict(row, "source_removed");
+    if (partDigest(source) !== row.digest)
+      throw conflict(row, "source_changed");
+    let message = byId.get(row.messageId);
+    if (!message) {
+      if (!reconstruct.has(row.messageId))
+        throw conflict(row, "candidate_loss");
+      const sourceIndex = input.indexOf(original);
+      const next = output.findIndex((candidate) => input.findIndex((entry) => entry.info.id === candidate.info.id) > sourceIndex);
+      message = structuredClone(original);
+      output.splice(next < 0 ? output.length : next, 0, message);
+      byId.set(row.messageId, message);
+      repaired = true;
+    }
+    const parts = message.parts;
+    if (row.partId === undefined) {
+      const candidate = parts[row.index];
+      if (partDigest(candidate) === row.digest)
+        continue;
+      const reversibleTag = source.type === "text" && typeof source.text === "string" && typeof candidate?.text === "string" && /^§\d+§ /.test(candidate.text) && candidate.text.replace(/^§\d+§ /, "") === source.text && partDigest({ ...candidate, text: source.text }) === row.digest;
+      if (!reversibleTag) {
+        if (!reconstruct.has(row.messageId))
+          throw conflict(row, "candidate_conflict");
+        message.parts = structuredClone(original.parts);
+        repaired = true;
+        continue;
+      }
+      parts[row.index] = structuredClone(source);
+      continue;
+    }
+    const matches = parts.flatMap((part, i) => part.id === row.partId ? [i] : []);
+    if (matches.length > 1)
+      throw conflict(row, "candidate_conflict");
+    const index = matches[0];
+    if (index !== undefined) {
+      if (partDigest(parts[index]) !== row.digest)
+        parts[index] = structuredClone(source);
+    } else if (["reasoning", "thinking", "redacted_thinking"].includes(String(source.type)) || reconstruct.has(row.messageId)) {
+      parts.splice(row.index, 0, structuredClone(source));
+      repaired = true;
+    } else
+      throw conflict(row, "candidate_loss");
+  }
+  return repaired;
+}
+function releaseRustServedRaw(db, sessionId, output, rebuiltIdentity) {
+  const snapshot = readReplayEnvelope(db, sessionId);
+  if (!records(snapshot).length && !snapshot.rustRawRebuild?.pending)
+    return;
+  const byId = new Map(output.map((message) => [message.info.id, message]));
+  if (!updateReplayDocument(db, sessionId, (doc) => {
+    const rows = records(doc);
+    const kept = rows.filter((row) => partDigest(sourcePart(row, byId.get(row.messageId))) === row.digest);
+    const recovery = doc.rustRawRebuild;
+    const acknowledged = recovery?.pending && recovery.identity === rebuiltIdentity;
+    if (kept.length === rows.length && !acknowledged)
+      return false;
+    doc.version = 2;
+    doc.rustServedRaw = kept;
+    if (acknowledged)
+      doc.rustRawRebuild = { ...recovery, pending: false };
+    return true;
+  }))
+    throw new EmergencyFailClosedError("Cannot release Rust served-raw evidence");
+}
+
 // src/hooks/magic-context/storage-busy-refusal.ts
 var STORAGE_BUSY_MESSAGE = "Magic Context's database is busy (another process held it too long); send your message again.";
 function describeStorageBusyCause(cause) {
@@ -19505,10 +19963,10 @@ function messageCacheSignature(message) {
   const parts = Array.isArray(message.parts) ? message.parts : [];
   const serializedParts = JSON.stringify(parts) ?? "null";
   const serializedMessage = JSON.stringify(message) ?? "null";
-  return `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash11("sha256").update(serializedMessage).digest("hex")}`;
+  return `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash12("sha256").update(serializedMessage).digest("hex")}`;
 }
 function advanceWireFingerprint(previous, encoded) {
-  return createHash11("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
+  return createHash12("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
 }
 function buildWireFingerprint(encoded) {
   let fingerprint = "rust-wire-v1";
@@ -20048,7 +20506,8 @@ function buildTransformBody(args) {
       args.providerId ? `provider:${args.providerId}` : "",
       args.modelKey ? `model:${args.modelKey}` : "",
       args.variant ? `variant:${args.variant}` : "",
-      args.systemPromptHash ? `system:${args.systemPromptHash}` : ""
+      args.systemPromptHash ? `system:${args.systemPromptHash}` : "",
+      args.rawRebuild ? `raw_replay:${args.rawRebuild.identity}` : ""
     ].filter(Boolean).join("|"),
     system_prompt_hash: args.systemPromptHash,
     adopted_system_prompt_hash: args.passInputs.adopted_system_prompt_hash,
@@ -20056,6 +20515,14 @@ function buildTransformBody(args) {
     is_subagent: args.passInputs.is_subagent === true,
     messages: args.input,
     native_messages: args.nativeMessages,
+    served_raw_block_ids: args.servedRawBlockIds ?? [],
+    ...args.rawRebuild?.pending ? {
+      raw_replay_rebuild: {
+        identity: args.rawRebuild.identity,
+        reason: args.rawRebuild.reason,
+        message_ids: args.rawRebuild.messageIds
+      }
+    } : {},
     tool_input_key_orders: args.toolInputKeyOrders ?? toolInputKeyOrders(args.input),
     ...args.fullArrayFingerprint ? { full_array_fingerprint: args.fullArrayFingerprint } : {},
     ...args.tailDelta ? {
@@ -20246,6 +20713,7 @@ function createRustModeTransform(deps, options) {
       throw error;
     } finally {
       clock.clearTimeout(timer);
+      invalidateReplayEnvelopeSnapshot(deps.db, args.sessionId);
     }
   };
   const callTransformWithStallProbe = async (args, attemptTimeoutMs) => {
@@ -20354,6 +20822,24 @@ function createRustModeTransform(deps, options) {
       logTransformTiming(sessionId, "rust.ordinal_rebuild", startedAt, detail);
     }
   };
+  const recordRawConflict = (sessionId, error) => {
+    requestRustRawRebuild(deps.db, sessionId, error);
+    dropSlot(sessionId, `raw_replay_${error.reason}`);
+    const state = ensureState(states, sessionId);
+    state.forceFullWire = true;
+    state.parked = false;
+    sessionLog2(sessionId, `raw_replay_rebuild_requested reason=${error.reason} first_changed=${error.firstBlockId}`);
+  };
+  const observeRawReplay = (sessionId, input, served) => {
+    try {
+      checkRustServedRawIngress(deps.db, sessionId, input);
+      noteRustServedRaw(deps.db, sessionId, input, served);
+    } catch (error) {
+      if (error instanceof RustServedRawConflict)
+        recordRawConflict(sessionId, error);
+      throw error;
+    }
+  };
   const replayLastGood = (sessionId, currentMessages, output, systemPromptTokens) => {
     try {
       if (states.get(sessionId)?.markerAdmissionFenced || isRustMarkerAdmissionFenced(deps.db, sessionId))
@@ -20440,6 +20926,7 @@ function createRustModeTransform(deps, options) {
       ownDirtyRevision: lkgDirtyRevision(sessionId)
     }));
     const replayInputCount = currentMessages.length;
+    observeRawReplay(sessionId, currentMessages, replay.messages);
     replaceMessagesInPlace(output, replay.messages);
     ensureState(states, sessionId).lkgLatestServedDigest = lkgServedArrayDigest(JSON.stringify(replay.messages));
     enterLkgReplayFreeze(ensureState(states, sessionId), replayInputCount);
@@ -20503,7 +20990,10 @@ function createRustModeTransform(deps, options) {
   const passStampBySession = new Map;
   const replayParticipant = {
     lastPassStamp: (sessionId) => states.has(sessionId) ? passStampBySession.get(sessionId) : undefined,
-    enterFreezeFromExternalServe: (sessionId, inputCount) => enterLkgReplayFreeze(ensureState(states, sessionId), inputCount),
+    enterFreezeFromExternalServe: (sessionId, inputMessages, servedMessages) => {
+      observeRawReplay(sessionId, inputMessages, servedMessages);
+      enterLkgReplayFreeze(ensureState(states, sessionId), inputMessages.length);
+    },
     replayFits: (sessionId, messages, inputMessages) => {
       try {
         const fit = lkgReplayFits({
@@ -20649,6 +21139,24 @@ function createRustModeTransform(deps, options) {
     bindSystemDateRequest(output, dateRequest);
     const passObservedAtMs = Date.now();
     const state = ensureState(states, sessionId);
+    let rawRebuild;
+    let rawReadError;
+    try {
+      rawRebuild = rustRawRebuild(deps.db, sessionId);
+      try {
+        checkRustServedRawIngress(deps.db, sessionId, messages);
+      } catch (error) {
+        if (!(error instanceof RustServedRawConflict) || !rawRebuild?.pending)
+          throw error;
+        requestRustRawRebuild(deps.db, sessionId, error);
+        rawRebuild = rustRawRebuild(deps.db, sessionId);
+      }
+    } catch (error) {
+      if (error instanceof RustServedRawConflict)
+        throw error;
+      rawReadError = error;
+    }
+    const reconstructRaw = new Set(rawRebuild?.messageIds ?? []);
     let entrySlot = getSlot(sessionId);
     try {
       entrySlot = loadPersistedLkgSlot(deps.db, sessionId, true) ?? entrySlot;
@@ -20687,6 +21195,7 @@ function createRustModeTransform(deps, options) {
     let decision = "error";
     let materializeReason = "none";
     let frozenReleaseReason = null;
+    let frozenReleaseFirstChanged = "unknown";
     let schedulerDecision;
     let responseCommitted;
     let responsePrefixBustPermitted;
@@ -20712,7 +21221,7 @@ function createRustModeTransform(deps, options) {
     let recoveryProjectRoot = options.projectRoot ?? deps.directory ?? "";
     const passUsageSnapshot = loadContextUsage(deps.contextUsageMap, deps.db, sessionId);
     requestInputTokens = Math.max(0, Math.floor(passUsageSnapshot.inputTokens));
-    let preflightError;
+    let preflightError = rawReadError;
     let markerAdmissionRecovery = state.markerAdmissionFenced;
     try {
       markerAdmissionRecovery ||= isRustMarkerAdmissionFenced(deps.db, sessionId);
@@ -20906,7 +21415,7 @@ function createRustModeTransform(deps, options) {
         decision,
         committed: responseCommitted,
         prefixBustPermitted: responsePrefixBustPermitted,
-        reason: materializeReason,
+        reason: applied && served && frozenReleaseReason ? `lkg_frozen_release:${frozenReleaseReason};first_changed=${frozenReleaseFirstChanged};materialize_reason=${materializeReason}` : materializeReason,
         schedulerDecision,
         schedulerDeferReason,
         historianNoFire,
@@ -20928,7 +21437,7 @@ function createRustModeTransform(deps, options) {
           materializeReason: materializeReason === "none" ? null : materializeReason,
           inputTokens: requestInputTokens,
           tsMs: passObservedAtMs,
-          lkgFrozenReleaseReason: applied && served ? frozenReleaseReason ?? undefined : undefined
+          lkgFrozenReleaseReason: applied && served && frozenReleaseReason ? `${frozenReleaseReason};first_changed=${frozenReleaseFirstChanged}` : undefined
         });
       }
     };
@@ -20963,7 +21472,7 @@ function createRustModeTransform(deps, options) {
           sessionLog2(sessionId, `rust module stages (slow pass): ${detail}`);
       }
     };
-    if (state.parked) {
+    if (state.parked && !preflightError) {
       state.passesSincePark += 1;
       if (!emergencyFailClosed && passUsageSnapshot.percentage < RUST_PARK_PROBE_PRESSURE_BYPASS_PCT && state.passCount % RUST_PARK_RETRY_INTERVAL !== 0) {
         decision = "parked";
@@ -21248,7 +21757,7 @@ function createRustModeTransform(deps, options) {
         const id = messageIdOf(message) ?? `index:${todoStart + offset}`;
         const parts = message.parts?.filter((part) => isRecord3(part) && part.type === "tool" && part.tool === "todowrite");
         if (parts?.length) {
-          todoCalls.set(id, createHash11("sha256").update(JSON.stringify(parts)).digest("hex"));
+          todoCalls.set(id, createHash12("sha256").update(JSON.stringify(parts)).digest("hex"));
         } else {
           todoCalls.delete(id);
         }
@@ -21394,6 +21903,8 @@ function createRustModeTransform(deps, options) {
       };
       let body = buildTransformBody({
         sessionId,
+        rawRebuild,
+        servedRawBlockIds: servedRawBlockIds(deps.db, sessionId),
         input: encodedInput,
         nativeMessages: wireDelta ? messages.slice(wireDelta.rawStart) : messages,
         toolInputKeyOrders: toolInputKeyOrders(encodedInput),
@@ -21593,6 +22104,8 @@ function createRustModeTransform(deps, options) {
           const retryWireBuildStartedAt = performance.now();
           body = buildTransformBody({
             sessionId,
+            rawRebuild,
+            servedRawBlockIds: servedRawBlockIds(deps.db, sessionId),
             input: retryEncodedInput,
             nativeMessages: messages,
             toolInputKeyOrders: toolInputKeyOrders(retryEncodedInput),
@@ -21652,6 +22165,13 @@ function createRustModeTransform(deps, options) {
         sessionLog2(sessionId, `signed thinking reset fence: ${fenced.length} assistant(s) [${fenced.join(",")}]`);
       }
       const cacheBustingPass = moduleDecisionBusts;
+      if (rawRebuild?.pending && !moduleDecisionBusts) {
+        throw new EmergencyFailClosedError("Rust raw-rebuild request was not authorized by the module");
+      }
+      if (rawRebuild?.pending) {
+        frozenReleaseReason = `raw_replay_${rawRebuild.reason}`;
+        frozenReleaseFirstChanged = rawRebuild.firstBlockId;
+      }
       let frozenReplayReleased = false;
       if (markerAdmissionRecovery && !moduleDecisionBusts)
         throw new RustTransformProtocolError("rust marker admission recovery: supported prefix_bust_permitted=true required; upgrade ck-mc if unsupported");
@@ -21683,6 +22203,7 @@ function createRustModeTransform(deps, options) {
         let appliedMessages = moduleMessages;
         let markerStrategyFailure;
         let replayedFrozenRepresentation = false;
+        let reconstructedRaw = false;
         const boundaryId = response.boundary_id;
         if (typeof boundaryId === "string" && boundaryId.length > 0) {
           assertNativeBoundary(moduleMessages, sessionId, boundaryId);
@@ -21727,7 +22248,7 @@ function createRustModeTransform(deps, options) {
         }
         if (recoveryFenceRebuild) {
           frozenReplayReleased = true;
-          frozenReleaseReason = "lkg_recovery_fence_unproven";
+          frozenReleaseReason ??= "lkg_recovery_fence_unproven";
           frozenReleaseLastServed = { messages: null, proven: false };
         }
         if (state.lkgRepresentationFrozen && !shouldAdoptModuleAfterFreeze(moduleDecisionBusts, frozenReplayReleased)) {
@@ -21792,6 +22313,10 @@ function createRustModeTransform(deps, options) {
         if (!replayedFrozenRepresentation) {
           const outputCloneStartedAt = performance.now();
           appliedMessages = cloneModuleNativeOutput(moduleMessages);
+          if (!moduleDecisionBusts || rawRebuild?.pending && rawRebuild.reason.startsWith("candidate")) {
+            const covered = moduleDecisionBusts && typeof response.coverage_ordinal === "number" ? new Set([...state.idOrdinalMemo].filter(([, ordinal]) => ordinal <= Number(response.coverage_ordinal)).map(([id]) => id)) : new Set;
+            reconstructedRaw = preserveRustServedRaw(deps.db, sessionId, appliedMessages, messages, reconstructRaw, covered);
+          }
           timings.outputClone += performance.now() - outputCloneStartedAt;
         }
         pendingWireCache.nativeOutput = moduleMessages;
@@ -21850,7 +22375,7 @@ function createRustModeTransform(deps, options) {
             prefixPermissionSupported: permissionSupported,
             moduleReasoningTrimOnly: response.reasoning_trim_only === true,
             moduleSignedThinkingReset: response.signed_thinking_reset === true,
-            ...permissionSupported && (passStartedFrozen || frozenReleaseReason || coldStartLastServed) ? { frozenReleaseLastServed } : {},
+            ...moduleDecisionBusts && (passStartedFrozen || frozenReleaseReason || coldStartLastServed) ? { frozenReleaseLastServed } : {},
             trailingBlankSourceDecisions,
             trailingBlankNewestAssistantId: typeof trailingBlankNewestAssistantId === "string" ? trailingBlankNewestAssistantId : undefined,
             tagger: deps.tagger,
@@ -21861,6 +22386,23 @@ function createRustModeTransform(deps, options) {
           if (markerStrategyFailure)
             throw markerStrategyFailure;
         }
+        if (!moduleDecisionBusts && !replayedFrozenRepresentation) {
+          reconstructedRaw = preserveRustServedRaw(deps.db, sessionId, appliedMessages, messages, reconstructRaw) || reconstructedRaw;
+          replayRustModeBindingMismatchStrips2({
+            db: deps.db,
+            sessionId,
+            messages: appliedMessages,
+            resolvedProviderID: model?.providerID
+          });
+          if (servedRawBlockIds(deps.db, sessionId).length > 0 && (!validateLkgSeam([], appliedMessages, model?.providerID ?? null) || model?.providerID === "anthropic" && !validateAnthropicReasoningRuns(appliedMessages.map((message) => ({
+            ...message,
+            parts: message.parts.filter((part) => !isRecord3(part) || !["text", "reasoning"].includes(String(part.type)) || part.text !== "")
+          }))))) {
+            throw new RustServedRawConflict("candidate_conflict", [
+              ...new Set(servedRawBlockIds(deps.db, sessionId).map((id) => id.replace(/#\d+$/, "")))
+            ], servedRawBlockIds(deps.db, sessionId)[0] ?? "unknown");
+          }
+        }
         if (typeof boundaryId === "string" && boundaryId.length > 0) {
           assertNativeBoundary(appliedMessages, sessionId, boundaryId);
         }
@@ -21896,6 +22438,24 @@ function createRustModeTransform(deps, options) {
           }
         }
         logStage(sessionId, "apply", applyStartedAt, timings);
+        if (frozenReleaseReason && frozenReleaseLastServed.messages && [...frozenReleaseLastServed.messages, ...appliedMessages].every((message) => isRecord3(message) && isRecord3(message.info) && Array.isArray(message.parts))) {
+          frozenReleaseFirstChanged = "none";
+          const byId = new Map(appliedMessages.map((message) => [message.info.id, message]));
+          for (const before of frozenReleaseLastServed.messages) {
+            const after = byId.get(before.info.id);
+            const index = before.parts.findIndex((part, i) => JSON.stringify(part) !== JSON.stringify(after?.parts[i]));
+            if (!after || index >= 0) {
+              const blockIndex = index > 0 ? encodeOpenCodeMessagesToCk([
+                { ...before, parts: before.parts.slice(0, index) }
+              ])[0].ck.content.length : 0;
+              frozenReleaseFirstChanged = `${before.info.id}#${blockIndex}`;
+              break;
+            }
+          }
+        }
+        if (replayedFrozenRepresentation || reconstructedRaw) {
+          noteRustServedRaw(deps.db, sessionId, messages, appliedMessages);
+        }
         const lkgInputIds = messages.map((message) => message.info.id);
         const lkgInputKeys = resolveLkgModelKeys(messages);
         const applyReplaceStartedAt = performance.now();
@@ -22153,6 +22713,9 @@ function createRustModeTransform(deps, options) {
           }
         }
       }
+      if (moduleDecisionBusts) {
+        releaseRustServedRaw(deps.db, sessionId, output.messages, rawRebuild?.identity);
+      }
     } catch (error) {
       if (markerDefinitelyNoCut) {
         try {
@@ -22290,7 +22853,12 @@ function createRustModeTransform(deps, options) {
   const adapter = {
     run: async (sessionId, messages, output, sessionMeta) => {
       try {
-        await withSqliteTransformPass2(() => run(sessionId, messages, output, sessionMeta));
+        await withReplayEnvelopeSnapshot(deps.db, sessionId, () => withSqliteTransformPass2(() => run(sessionId, messages, output, sessionMeta)));
+      } catch (error) {
+        if (error instanceof RustServedRawConflict) {
+          recordRawConflict(sessionId, error);
+        }
+        throw error;
       } finally {
         try {
           withoutSqliteTransformPass2(() => resolveHostRunner()?.pump(sessionId));
@@ -24394,7 +24962,7 @@ function createRustRefusalRecovery(options) {
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 
 // src/hooks/magic-context/system-prompt-dates.ts
 function replaceHostDates(prompt, replace) {
@@ -24507,7 +25075,7 @@ function createSystemPromptHashHandler(deps) {
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
-    const stableCandidateHash = createHash12("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = createHash13("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
     let deferredDateRefresh = false;
@@ -24521,7 +25089,7 @@ function createSystemPromptHashHandler(deps) {
         try {
           const content = liveElements.join(`
 `);
-          const hash = createHash12("md5").update(promptSurfaceHashMaterial(content, promptSurface.preset)).digest("hex");
+          const hash = createHash13("md5").update(promptSurfaceHashMaterial(content, promptSurface.preset)).digest("hex");
           updateSessionMeta(deps.db, sessionId, {
             systemPromptHash: hash,
             cachedM0SystemHash: hash,
@@ -24561,7 +25129,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash12("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = createHash13("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
     recordSystemPromptForRequest(sessionId, currentLkgRequestIdentity(sessionId), currentHash, deps.db, previousHash !== currentHash ? !deps.historyRefreshSessions.has(sessionId) : undefined, deps.historyRefreshSessions, deps.pendingMaterializationSessions);
     if (!sessionMetaEarly) {
       return;
@@ -24621,6 +25189,114 @@ function createSystemPromptHashHandler(deps) {
   };
 }
 
+// src/shared/recovery-reasoning-prefix.ts
+function recoveryReasoningPrefixes(messages, partsKey) {
+  const prefixes = [];
+  for (let index = 0;index < messages.length; index++) {
+    const message = messages[index];
+    const parts = message?.[partsKey];
+    if (!Array.isArray(parts))
+      continue;
+    for (let p = 0;p < parts.length; p++) {
+      const type = parts[p]?.type;
+      if (type !== "thinking" && type !== "reasoning" && type !== "redactedThinking" && type !== "redacted_thinking")
+        continue;
+      prefixes.push(JSON.stringify([
+        ...messages.slice(0, index),
+        { ...message, [partsKey]: parts.slice(0, p + 1) }
+      ]));
+    }
+  }
+  return prefixes;
+}
+
+// src/hooks/magic-context/replay-committed-drops.ts
+function replayCommittedDrops(db, sessionId, messages) {
+  const original = messages;
+  const reasoningPrefixes = recoveryReasoningPrefixes(messages, "parts");
+  if (reasoningPrefixes.length)
+    messages = structuredClone(messages);
+  const tags = getTagsBySession2(db, sessionId).filter((tag) => tag.status === "dropped");
+  const toolTags = new Map(tags.filter((tag) => tag.type === "tool").map((tag) => [makeToolCompositeKey(tag.toolOwnerMessageId ?? "", tag.messageId), tag]));
+  const textTags = new Map(tags.filter((tag) => tag.type !== "tool").map((tag) => [tag.messageId, tag]));
+  const byNumber = new Map(tags.map((tag) => [tag.tagNumber, tag]));
+  const index = new Map;
+  const owners = new Map;
+  const resolvedOwners = new Map;
+  const ambiguousCalls = new Set;
+  const targets = new Map;
+  let precedingThinking = [];
+  const toolThinking = new Map;
+  const batch = new ToolMutationBatch(messages);
+  for (const message of messages) {
+    if (message.info.role === "user")
+      precedingThinking = [];
+    const thinking = message.parts.filter(isThinkingPart);
+    for (let p = 0;p < message.parts.length; p++) {
+      const part = message.parts[p];
+      const observation = extractToolCallObservation(part);
+      if (observation) {
+        const { callId, kind } = observation;
+        const pending = owners.get(callId) ?? [];
+        if (pending.length > 1)
+          ambiguousCalls.add(callId);
+        const hostingKey = makeToolCompositeKey(message.info.id ?? "", callId);
+        const owner = kind === "invocation" || part.type === "tool" || toolTags.has(hostingKey) ? message.info.id ?? "" : pending.shift() ?? resolvedOwners.get(callId) ?? message.info.id ?? "";
+        if (kind === "invocation")
+          pending.push(owner);
+        else
+          resolvedOwners.set(callId, owner);
+        owners.set(callId, pending);
+        const key = makeToolCompositeKey(owner, callId);
+        if (message.info.role === "tool" && !toolThinking.has(key))
+          toolThinking.set(key, precedingThinking);
+        const entry = index.get(key) ?? { occurrences: [], hasResult: false };
+        entry.occurrences.push({ message, part, kind });
+        entry.hasResult ||= kind === "result" && partHasCompletedResult(part);
+        index.set(key, entry);
+      } else {
+        const prefix = isTextPart(part) ? /^§(\d+)§\s/.exec(part.text) : null;
+        const tag = (prefix ? byNumber.get(Number(prefix[1])) : undefined) ?? textTags.get(`${message.info.id}:p${p}`) ?? textTags.get(`${message.info.id}:file${p}`);
+        if (tag && tag.type !== "tool")
+          targets.set(tag.tagNumber, {
+            message,
+            setContent(content) {
+              if (isTextPart(part)) {
+                if (part.text === content)
+                  return false;
+                part.text = content;
+              } else
+                message.parts[p] = { type: "text", text: content };
+              return true;
+            }
+          });
+      }
+    }
+    if (message.info.role === "assistant" && !message.parts.some(isTextPart))
+      precedingThinking = thinking;
+  }
+  const arcsByCall = new Map;
+  for (const entry of index.values()) {
+    const callId = extractToolCallObservation(entry.occurrences[0]?.part)?.callId ?? "";
+    arcsByCall.set(callId, (arcsByCall.get(callId) ?? 0) + 1);
+  }
+  for (const [key, entry] of index) {
+    const callId = extractToolCallObservation(entry.occurrences[0]?.part)?.callId ?? "";
+    if (ambiguousCalls.has(callId))
+      continue;
+    const tag = toolTags.get(key) ?? (arcsByCall.get(callId) === 1 ? toolTags.get(makeToolCompositeKey("", callId)) : undefined);
+    if (tag)
+      targets.set(tag.tagNumber, createToolDropTarget(key, toolThinking.get(key) ?? [], index, batch, tag.tagNumber));
+  }
+  applyFlushedStatuses(sessionId, db, targets, tags);
+  batch.finalize();
+  if (JSON.stringify(recoveryReasoningPrefixes(messages, "parts")) !== JSON.stringify(reasoningPrefixes))
+    return false;
+  if (messages !== original)
+    original.splice(0, original.length, ...messages);
+  return true;
+}
+
 // src/plugin/messages-transform.ts
 var ASSISTANT_TERMINAL_RETRY_MESSAGE = "The conversation ends with a completed assistant response and cannot be resubmitted as-is — send a new message to continue.";
 
@@ -24763,7 +25439,6 @@ function tryMessagesTransformLkgReplay(args) {
         sessionLog2(sessionId, "lkg_emergency_armed");
       } else {
         const inputMessages = output.messages;
-        const inputCount = inputMessages.length;
         const keys = resolveLkgModelKeys(inputMessages);
         const replay = replayLkg({
           sessionId,
@@ -24782,6 +25457,10 @@ function tryMessagesTransformLkgReplay(args) {
           sessionLog2(sessionId, "lkg_restart_rebuild_required");
           return false;
         }
+        if (replay.ok && !rust && !replayCommittedDrops(db, sessionId, replay.messages)) {
+          sessionLog2(sessionId, "lkg_reasoning_prefix_changed");
+          return false;
+        }
         let tsFit = true;
         if (replay.ok && !rust && keys.providerKey && keys.modelKey) {
           const model = {
@@ -24831,8 +25510,8 @@ function tryMessagesTransformLkgReplay(args) {
             return false;
           retirePendingSystemPromptDelivery(sessionId);
           args.onLkgReplay?.();
+          noteExternalLkgReplay(rust, sessionId, inputMessages, replay.messages);
           replaceMessagesInPlace2(output, replay.messages);
-          noteExternalLkgReplay(rust, sessionId, inputCount);
           sessionLog2(sessionId, "lkg_replay_served");
           return true;
         } else {
@@ -25228,7 +25907,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -25452,11 +26131,61 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord4(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash13("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash14("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   return selected ? renderPartFull(selected) ?? "" : `Tag ${number}'s original text part is no longer in stored history.`;
 }
 
+// src/tools/ctx-expand/search-archive.ts
+function renderSearchArchive(db, sessionId, start, end, tokenBudget, archiveOnly = false) {
+  return withMessageFtsSessionFilter(db, sessionId, (sessionFirst) => {
+    let rawIds;
+    const rows = db.prepare(sessionFirst ? `SELECT f.message_ordinal AS ordinal, f.message_id AS id, f.role, f.content
+                   FROM message_fts_rowid_map AS m
+                   JOIN message_history_fts AS f ON f.rowid = m.fts_rowid
+                   WHERE m.session_id = ?1 AND m.message_ordinal BETWEEN ?2 AND ?3
+                     AND f.session_id = ?1 AND f.message_ordinal BETWEEN ?2 AND ?3
+                   ORDER BY m.message_ordinal` : `SELECT message_ordinal AS ordinal, message_id AS id, role, content
+                   FROM message_history_fts
+                   WHERE session_id = ?1 AND message_ordinal BETWEEN ?2 AND ?3
+                   ORDER BY CAST(message_ordinal AS INTEGER)`);
+    const blocks = [];
+    let tokens = 0;
+    let lastOrdinal = start - 1;
+    let truncated = false;
+    for (const row of rows.iterate(sessionId, start, end)) {
+      if (!row.content)
+        continue;
+      if (!archiveOnly) {
+        rawIds ??= readRawSessionMessageIdOrdinalsForRange2(sessionId, start, end);
+        if (rawIds.get(row.id) === row.ordinal)
+          continue;
+      }
+      const block = `[${row.ordinal}] ${row.role === "user" ? "U" : "A"}: ${row.content}`;
+      const cost = estimateTokens(block);
+      if (blocks.length > 0 && tokens + cost > tokenBudget) {
+        truncated = true;
+        break;
+      }
+      blocks.push(block);
+      tokens += cost;
+      lastOrdinal = row.ordinal;
+    }
+    if (blocks.length === 0)
+      return null;
+    const text = [
+      "From the search archive: indexed text only; no surrounding messages or tool output.",
+      "",
+      ...blocks
+    ];
+    if (truncated) {
+      text.push("", `Truncated at message ${lastOrdinal} (budget: ~${tokenBudget} tokens). Call ctx_expand(start=${lastOrdinal + 1}, end=${end}) for more archived text.`);
+    }
+    return text.join(`
+`);
+  });
+}
+
 // src/tools/ctx-expand/tools.ts
 var ctxExpandArgsShape = {
   tag: tool.schema.union([tool.schema.number(), tool.schema.string()]).optional().describe("Tag number from a §N§ tag or a [dropped §N§] placeholder, not a message ordinal. Returns that one item in full. Use alone."),
@@ -25490,7 +26219,7 @@ function createCtxExpandTool(deps) {
         return renderItemByTag(deps.db, sessionId, mode.tag);
       }
       if (mode.kind === "message") {
-        return renderMessageByOrdinal(sessionId, mode.message);
+        return renderSearchArchive(deps.db, sessionId, mode.message, mode.message, CTX_EXPAND_TOKEN_BUDGET) ?? renderMessageByOrdinal(sessionId, mode.message);
       }
       const { start, end, verbose } = mode;
       const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
@@ -25498,6 +26227,9 @@ function createCtxExpandTool(deps) {
         return `Range ${start}-${end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
       }
       const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(end, lastCompartmentEnd) : end;
+      const archived = renderSearchArchive(deps.db, sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
+      if (archived)
+        return archived;
       if (verbose) {
         const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET, deps.expandTools);
         if (!v.text) {
@@ -26353,9 +27085,9 @@ function isMissingError(error) {
 }
 
 // ../retina-local-fs/src/provider.ts
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
-var execFileAsync2 = promisify3(execFile3);
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync3 = promisify4(execFile4);
 function parseSemver(value) {
   const match = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
   if (!match) {
@@ -27004,7 +27736,7 @@ function formatCtxReduceReply(stampedCount, selfStampCount = 0) {
   return parts.join(" ");
 }
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { tool as tool4 } from "@opencode-ai/plugin";
 
 // src/features/magic-context/range-parser.ts
@@ -27068,11 +27800,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash14("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash15("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash14("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash15("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool4({
     description: CTX_REDUCE_DESCRIPTION,