@cortexkit/opencode-magic-context 0.49.15 → 0.49.17

package/dist/v2/{context-4qczzck7.js → context-jn3zpeqh.js}

@@ -6,7 +6,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-zc3e54vy.js";
+} from "./server-nj659894.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -46,7 +46,7 @@ import {
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   DEFAULT_LOCAL_EMBEDDING_MODEL,
   DREAM_TASK_PROMOTION_DEFAULTS
-} from "./server-th4y11y7.js";
+} from "./server-271qxsf5.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -86,10 +86,6 @@ import {
   getUnpublishedAutoSearchNoHint,
   forgetUnpublishedAutoSearchNoHint,
   registerAutoSearchWork,
-  gaDatabasePath,
-  RAW_MESSAGE_TYPES,
-  V2StoreReaderPool,
-  V2StoreReader,
   getOrCreateSessionMeta,
   updateSessionMeta,
   advanceToolReclaimWatermark,
@@ -283,7 +279,7 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-dd0tz6cn.js";
+} from "./server-fw7wrk01.js";
 import {
   resolveHistorianModel2
 } from "./server-8cd2j99z.js";
@@ -308,8 +304,9 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-kmbarfmn.js";
+} from "./server-gtfhttbr.js";
 import {
+  pruneMissingProjectIdentities,
   setHomeProjectPermission,
   shouldSkipHomeProjectMemory,
   ProjectIdentityError,
@@ -324,13 +321,14 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./server-gvkm8xaj.js";
+} from "./server-rmygf5pn.js";
 import {
   detectLatestTurnThinkingMismatch,
   isPrefixBoundThinkingModel,
   detectOverflow,
   ensureSessionMetaRow,
   clearCachedM0M1,
+  clearCachedM0,
   expandToolPart,
   markHostUnservedRow,
   estimateTrueRawMessageTokens,
@@ -512,7 +510,7 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-ehyava47.js";
+} from "./server-kh7dpa1a.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -541,7 +539,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./server-hek6z3w6.js";
+} from "./server-8by8qfec.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -552,7 +550,7 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   normalizeText
-} from "./server-0ppsweh6.js";
+} from "./server-tgnbmwah.js";
 import {
   SubcClient,
   connectionFileExists,
@@ -560,7 +558,7 @@ import {
   toSynapseLaneDescriptor,
   formatSynapseLaneDescriptor,
   SynapseEmbeddingProvider
-} from "./server-rrqpvwqd.js";
+} from "./server-6tmj0s7j.js";
 import {
   inRootAsyncContext2,
   getTagIdentityWriteGeneration2,
@@ -574,11 +572,19 @@ import {
   isTransientSqliteError2,
   SqliteAcquisitionBusyError2,
   withAsyncPrivilegedWriter2
-} from "./server-wafzvyhg.js";
-import"./server-yrvqaswb.js";
+} from "./server-beht37jy.js";
+import"./server-51779zs2.js";
+import {
+  isRawCompactionSummaryInfo2,
+  extractInMemoryMessageViews2,
+  buildInMemoryTailRawMessages2,
+  RawOrdinalsNotReady2,
+  runSessionWarmupWorker
+} from "./server-xj136kt8.js";
+import"./server-1wy7b9de.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./server-qhfvvfxj.js";
+} from "./server-46neh5fa.js";
 import {
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -597,14 +603,20 @@ import {
   prepareLkgCaptureFence,
   certifyCommittedLkgCapture,
   markLkgRecoveryDirty,
+  cleanSearchText,
+  matchedSearchSnippet,
+  gaDatabasePath,
+  RAW_MESSAGE_TYPES,
+  V2StoreReaderPool,
+  V2StoreReader,
   advanceSessionActivity,
   backfillSessionActivity,
   getLastIndexedOrdinal2,
   getMessageIndexReconciliationStartOrdinal2,
   isMessageIndexReconciledThrough2,
   indexMessagesAfterOrdinal2,
-  sweepOrphanedOpenCodeMessageIndexes2
-} from "./server-e298hswg.js";
+  sweepOrphanedOpenCodeMessageIndexesCooperatively2
+} from "./server-3rhpvy84.js";
 import {
   stableStringify,
   getTemporalDecisions,
@@ -663,12 +675,14 @@ import {
   getPendingOpsCount,
   clearPendingOps,
   removePendingOp,
+  updateTagByteSize2,
   getRecentTagOwnerMessageIds2,
   AGE_RECLAIM_MIN_TOKENS2,
   getOldestActiveUnprotectedToolTags2,
   getActiveToolTagsForAgeReclaim2,
   getTriggerTagTokenUpperBound2,
   getActiveTagTokenTotalsByMessage2,
+  updateTagTokenCount2,
   tryGetReasoningTokenEstimatesByMessage2,
   cachedTagOwnerRatios2,
   tagOwnerWarmupState2,
@@ -705,15 +719,7 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./server-atbc19ab.js";
-import"./server-51779zs2.js";
-import {
-  isRawCompactionSummaryInfo2,
-  extractInMemoryMessageViews2,
-  buildInMemoryTailRawMessages2,
-  RawOrdinalsNotReady2,
-  runSessionWarmupWorker
-} from "./server-prg55b7k.js";
+} from "./server-zyzawhdw.js";
 import {
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
@@ -729,12 +735,12 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./server-d8tj10db.js";
+} from "./server-n1prf1g6.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition,
   getMeasuredToolDefinitionTokens
-} from "./server-zs8d0s3b.js";
+} from "./server-g3qma5c0.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -747,7 +753,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-k2bzedxk.js";
+} from "./server-gpvay0xz.js";
 import {
   configureContextDatabasePragmas2
 } from "./server-fb3zxn06.js";
@@ -793,7 +799,7 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-6cdy4rc0.js";
+} from "./server-my7k4eds.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
@@ -801,7 +807,7 @@ import {
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
 } from "./server-34kwfsr4.js";
-import"./server-05xjtq6c.js";
+import"./server-d04vrx0j.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
@@ -814,7 +820,7 @@ import {
   releaseGitSweepLease,
   recordSessionProjectIdentity,
   hasRecordedSessionProjectIdentity
-} from "./server-4gn3z5an.js";
+} from "./server-hy3d3vsx.js";
 import {
   saveEmbeddingIfHashMatches,
   invalidateProject2,
@@ -822,10 +828,10 @@ import {
 } from "./server-4dhv7mqz.js";
 import {
   getLocalEmbeddingNativeMemoryStats
-} from "./server-g10mdym6.js";
+} from "./server-h1v0pyxb.js";
 import {
   cosineSimilarity
-} from "./server-ef89gdsx.js";
+} from "./server-zzkj2fch.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -850,7 +856,7 @@ import {
   mergeMemoryStats2,
   archiveMemory2,
   getMemoryCountsByStatus2
-} from "./server-n78avt2p.js";
+} from "./server-n37sebck.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -862,7 +868,7 @@ import"./server-h0410h0v.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-vbe4se57.js";
+} from "./server-a9xqj88f.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -877,16 +883,19 @@ import {
   SubcModuleTransport,
   indexCommitsForProject,
   embedUnembeddedCommits,
-  withMessageFtsSessionFilter,
   createUnifiedSearchDiagnostics2,
   parseIdShapedQuery2,
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-cfbr1s2x.js";
+} from "./server-vsw8tmm6.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
+import"./server-kaqs6h31.js";
+import {
+  renderSearchArchiveOffThread2
+} from "./server-ec4ca92p.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
@@ -1633,6 +1642,9 @@ __export(exports_coerce, {
   string: () => string3
 });
 
+// src/v2/hooks/context.ts
+import { setTimeout as delay } from "node:timers/promises";
+
 // src/config/dependency-notes.ts
 function scheduledTasks(config) {
   const tasks = config.dreamer?.tasks ?? {};
@@ -3420,9 +3432,14 @@ function scheduleReconciliation(db, sessionId, readMessages) {
   });
 }
 async function sweepOrphanedOpenCodeMessageIndexesOffThread(db, openSource, options = {}) {
+  if (getHarness2() === "opencode2")
+    openSource = () => new Database2(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), {
+      readonly: true,
+      fileMustExist: true
+    });
   const path = getSqliteDatabasePath2(db);
-  if (!path || getHarness2() !== "opencode")
-    return sweepOrphanedOpenCodeMessageIndexes2(db, openSource, options);
+  if (!path || getHarness2() !== "opencode" && getHarness2() !== "opencode2")
+    return sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, openSource, options);
   let source = null;
   let sourcePath = null;
   try {
@@ -3434,7 +3451,7 @@ async function sweepOrphanedOpenCodeMessageIndexesOffThread(db, openSource, opti
       source?.close();
   }
   if (!sourcePath)
-    return sweepOrphanedOpenCodeMessageIndexes2(db, () => source, options);
+    return sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, () => source, options);
   const reply = await runSessionWarmupWorker({
     path,
     sessionId: "",
@@ -3509,7 +3526,8 @@ function seedSessionCacheTtlIfUnsynced(args) {
 }
 
 // src/hooks/magic-context/auto-search-deadline.ts
-var AUTO_SEARCH_TIMEOUT_MS = 3000;
+var AUTO_SEARCH_TIMEOUT_MS = 1000;
+var AUTO_SEARCH_VECTOR_TIMEOUT_MS = 200;
 var operationDeadlines = new WeakMap;
 function autoSearchDeadlineUnixMs(signal) {
   const deadline = signal && operationDeadlines.get(signal);
@@ -4058,32 +4076,32 @@ function formatAge(committedAtMs) {
   const years = Math.floor(days / 365);
   return years === 1 ? "1y ago" : `${years}y ago`;
 }
-function renderFragment(result, charCap, wordRules) {
+function renderFragment(result, charCap, wordRules, query) {
   switch (result.source) {
     case "memory": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "git_commit": {
-      const subject = result.content.split(/\r?\n/)[0] ?? result.content;
+      const subject = cleanSearchText(result.content.split(/\r?\n/)[0] ?? result.content);
       const body = truncate(subject, Math.max(10, charCap - 20));
       return `commit ${result.shortSha} ${formatAge(result.committedAtMs)}: ${body}`;
     }
     case "message": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(query ? matchedSearchSnippet(result.content, query, charCap) : cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "compartment": {
-      const source = result.snippet ?? result.title;
+      const source = cleanSearchText(result.title);
       const compressed = cavemanCompress(source, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "primer": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "note": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
   }
@@ -4094,7 +4112,7 @@ function buildAutoSearchHint(results, options = {}) {
   const picks = results.slice(0, maxFragments);
   const lines = [];
   for (const result of picks) {
-    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english");
+    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english", options.query ?? "");
     if (fragment.length === 0)
       continue;
     lines.push(`- ${fragment}`);
@@ -4117,6 +4135,9 @@ ${trimmedBody}…
   }
   return wrapped;
 }
+function selectAutoSearchResults(results, threshold) {
+  return results.filter((result) => (result.relevanceScore ?? result.score) >= threshold);
+}
 
 // src/hooks/magic-context/auto-search-worker-client.ts
 import { Worker } from "node:worker_threads";
@@ -4212,6 +4233,63 @@ async function searchAutoHint(db, sessionId, projectPath, query, options, entry
   return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
 }
 var pendingBackfills = new WeakMap;
+var searchWorkers = new WeakMap;
+var liveSearchWorkers = new Set;
+var MAX_IDLE_SEARCH_WORKERS = 4;
+var SEARCH_WORKER_IDLE_MS = 5 * 60000;
+var workersCreated = 0;
+var workersReused = 0;
+async function acquireSearchWorker(db, key, entry, input, signal) {
+  const pool = searchWorkers.get(db) ?? new Map;
+  searchWorkers.set(db, pool);
+  while (!signal.aborted) {
+    let slot = pool.get(key);
+    if (slot?.busy) {
+      const current = slot;
+      await new Promise((resolve) => {
+        const done = () => {
+          signal.removeEventListener("abort", done);
+          resolve();
+        };
+        signal.addEventListener("abort", done, { once: true });
+        current.busy?.then(done);
+        if (signal.aborted)
+          done();
+      });
+      continue;
+    }
+    const fresh = !slot;
+    if (!slot) {
+      const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      slot = {
+        worker,
+        dispose() {
+          clearTimeout(this.idleTimer);
+          if (pool.get(key) === this)
+            pool.delete(key);
+          liveSearchWorkers.delete(this);
+          worker.terminate();
+          worker.unref();
+        }
+      };
+      workersCreated++;
+      pool.set(key, slot);
+      liveSearchWorkers.add(slot);
+      const current = slot;
+      worker.on("error", () => current.dispose());
+      worker.on("exit", () => current.dispose());
+    } else
+      workersReused++;
+    clearTimeout(slot.idleTimer);
+    const current = slot;
+    current.busy = new Promise((resolve) => {
+      current.release = resolve;
+    });
+    current.worker.ref();
+    return { slot: current, fresh };
+  }
+  return null;
+}
 function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   if (isEmbeddingHostBusy2())
     return Promise.resolve();
@@ -4276,6 +4354,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     query,
     options: {
       ...serializable,
+      autoHint: true,
       backfillMemoryEmbeddings: false,
       countRetrievals: false,
       measurementDisabled: true
@@ -4285,8 +4364,20 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     snapshot,
     deadlineUnixMs: autoSearchDeadlineUnixMs(deadlineSignal)
   };
+  let lease;
+  try {
+    lease = await acquireSearchWorker(db, `${input.harness}\x00${projectPath}\x00${job}\x00${entry.href}`, entry, input, signal);
+  } catch (error) {
+    lifecycle.done();
+    throw error;
+  }
+  if (!lease) {
+    lifecycle.done();
+    return [];
+  }
+  const { slot, fresh } = lease;
+  const worker = slot.worker;
   return new Promise((resolve, reject) => {
-    const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: input }));
     let settled = false;
     const finish = (results, error) => {
       if (settled)
@@ -4295,7 +4386,25 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       signal?.removeEventListener("abort", abort);
       lifecycle.signal.removeEventListener("abort", abort);
       lifecycle.done();
-      worker.terminate();
+      worker.off("message", onMessage);
+      worker.off("error", onError);
+      worker.off("exit", onExit);
+      if (error || signal.aborted || entry.href !== defaultAutoSearchWorkerEntry().href)
+        slot.dispose();
+      else {
+        slot.idleTimer = setTimeout(() => slot.dispose(), SEARCH_WORKER_IDLE_MS);
+        slot.idleTimer.unref?.();
+      }
+      const release = slot.release;
+      slot.busy = undefined;
+      slot.release = undefined;
+      release?.();
+      const reusable = liveSearchWorkers.delete(slot);
+      if (reusable)
+        liveSearchWorkers.add(slot);
+      const idle = [...liveSearchWorkers].filter((candidate) => !candidate.busy);
+      for (const prior of idle.slice(0, Math.max(0, idle.length - MAX_IDLE_SEARCH_WORKERS)))
+        prior.dispose();
       worker.unref();
       if (error)
         reject(error);
@@ -4305,9 +4414,9 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     const abort = () => finish([]);
     signal?.addEventListener("abort", abort, { once: true });
     lifecycle.signal.addEventListener("abort", abort, { once: true });
-    worker.on("error", (error) => finish([], error));
-    worker.on("exit", (code) => finish([], new Error(`auto-search worker exited (${code})`)));
-    worker.on("message", async (reply) => {
+    const onError = (error) => finish([], error);
+    const onExit = (code) => finish([], new Error(`auto-search worker exited (${code})`));
+    const onMessage = async (reply) => {
       if (settled)
         return;
       if (reply.kind === "result") {
@@ -4326,7 +4435,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       const response = { id: reply.id };
       try {
         if (reply.kind === "query")
-          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : embedQuery?.(reply.text, signal)) ?? null;
+          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
         else {
           const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
           const current = getProjectEmbeddingSnapshot2(projectPath);
@@ -4341,13 +4450,46 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
         response.error = error instanceof Error ? error.message : String(error);
       }
       response.embeddingHostBusy = isEmbeddingHostBusy2();
-      if (!settled && !signal?.aborted)
-        worker.postMessage(response);
-    });
+      if (!settled && !signal?.aborted) {
+        try {
+          worker.postMessage(response);
+        } catch (error) {
+          finish([], error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    };
+    worker.on("error", onError);
+    worker.on("exit", onExit);
+    worker.on("message", onMessage);
     if (signal?.aborted)
       abort();
+    else if (!fresh) {
+      try {
+        worker.postMessage({ kind: "run", input });
+      } catch (error) {
+        finish([], error instanceof Error ? error : new Error(String(error)));
+      }
+    }
   });
 }
+async function boundedHintEmbedding(embed, text, signal) {
+  const controller = new AbortController;
+  const combined = AbortSignal.any([signal, controller.signal]);
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => embed?.(text, combined) ?? null),
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          resolve(null);
+          controller.abort();
+        }, AUTO_SEARCH_VECTOR_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function defaultAutoSearchWorkerEntry() {
   return new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url);
 }
@@ -4655,6 +4797,8 @@ async function runAutoSearchHint(args) {
         const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? options.gitCommitsEnabled ?? false;
         const searchOptions = {
           limit: 10,
+          maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
+          excludeMessageId: userMsgId,
           memoryEnabled,
           embeddingEnabled,
           gitCommitsEnabled,
@@ -4692,11 +4836,15 @@ async function runAutoSearchHint(args) {
       if (results.length === 0) {
         return writeNoHintAndReconcile("empty");
       }
-      if (results[0].score < options.scoreThreshold) {
-        sessionLog2(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${options.scoreThreshold}`);
+      results = selectAutoSearchResults(results, options.scoreThreshold);
+      if (results.length === 0) {
+        sessionLog2(sessionId, `auto-search: no fragment meets relevance threshold ${options.scoreThreshold}`);
         return writeNoHintAndReconcile("below-threshold");
       }
-      const hintText = buildAutoSearchHint(results, { wordRules: options.wordRules });
+      const hintText = buildAutoSearchHint(results, {
+        wordRules: options.wordRules,
+        query: rawPrompt
+      });
       if (!hintText) {
         return writeNoHintAndReconcile("empty");
       }
@@ -6951,27 +7099,43 @@ function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
 function applyNewToolDrop(target, options) {
-  if (options.persist && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+  const plan = planNewToolDrop(target, options, !!options.persist);
+  if (!plan)
     return { result: "incomplete", mode: "full" };
+  options.persist?.(plan.mode);
+  return plan.apply();
+}
+function planNewToolDrop(target, options, prepare, plannedRemovals) {
+  if (prepare && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+    return;
   }
   if (!target) {
-    options.persist?.("full");
-    return { result: "absent", mode: "full" };
+    return { mode: "full", apply: () => ({ result: "absent", mode: "full" }) };
   }
-  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.() === true) {
+  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.(plannedRemovals) === true) {
     const strip = target.hasAttachments?.() === true;
-    options.persist?.(strip ? "skeleton_stripped" : "skeleton_real");
+    const mode = strip ? "skeleton_stripped" : "skeleton_real";
     return {
-      result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
-      mode: strip ? "skeleton_stripped" : "skeleton_real"
+      mode,
+      apply: () => ({
+        result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
+        mode
+      })
     };
   }
-  options.persist?.("full");
-  const result = target.drop?.() ?? "absent";
-  if (result === "truncated" && target.hasAttachments?.() === true) {
-    return { result: target.skeletonStripped?.() ?? "absent", mode: "skeleton_stripped" };
-  }
-  return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+  return {
+    mode: "full",
+    apply: () => {
+      const result = target.drop?.() ?? "absent";
+      if (result === "truncated" && target.hasAttachments?.() === true) {
+        return {
+          result: target.skeletonStripped?.() ?? "absent",
+          mode: "skeleton_stripped"
+        };
+      }
+      return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+    }
+  };
 }
 function applyPersistedToolDrop(db, sessionId, tagNumber, target, options, afterWrite) {
   return applyNewToolDrop(target, {
@@ -7065,6 +7229,7 @@ function renderConvertedToolSkeletons(targets, converted) {
   }
   return didMutate;
 }
+var PENDING_OPERATION_CHUNK_SIZE = 64;
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
   let diagnostics;
@@ -7074,153 +7239,184 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
     diagnostics.reasons[reason] = (diagnostics.reasons[reason] ?? 0) + 1;
   };
   let admitted = false;
-  try {
-    db.transaction(() => {
-      admitted = true;
-    }).immediate();
-    {
-      const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
-      onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
-      const tags = preloadedTags ?? getTagsByNumbers2(db, sessionId, [
-        ...new Set([
-          ...pendingOps.map((op) => op.tagId),
-          ...syntheticPendingOps.map((op) => op.tagId)
-        ])
-      ]);
-      const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
-      const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
-      const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
-      const opsToApply = [
-        ...pendingOps.map((op) => ({ op, synthetic: false })),
-        ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
-      ];
-      diagnostics = {
-        source: pendingOps.length > 0 && syntheticPendingOps.length > 0 ? "mixed" : syntheticPendingOps.length > 0 ? "synthetic" : "pending",
-        total: opsToApply.length,
-        mutated: 0,
-        persistedWithoutMutation: 0,
-        reasons: {}
-      };
-      const skeletonWindow = new Set(preloadedTags ? tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW) : getNewestToolTagNumbers2(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
-      for (const { op: pendingOp, synthetic } of opsToApply) {
-        let operationMutated = false;
-        const tagStatus = tagStatusById.get(pendingOp.tagId);
-        if (tagStatus === "compacted" || tagStatus === "dropped") {
-          reject("already_reduced");
-          if (!synthetic)
-            removePendingOp(db, sessionId, pendingOp.tagId);
-          continue;
-        }
-        const target = targets.get(pendingOp.tagId);
-        const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
-        if (veto) {
-          reject(veto);
-          continue;
-        }
-        const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
-        if (synthetic) {
-          if (!isToolTag) {
-            reject("synthetic_non_tool");
-            continue;
-          }
-          if (target?.canDrop?.() !== true) {
-            reject("synthetic_target_not_droppable");
-            continue;
-          }
+  let startedAt = 0;
+  const mutations = [];
+  let drainChunk;
+  let hasMore = false;
+  do {
+    admitted = false;
+    startedAt = 0;
+    try {
+      db.transaction(() => {
+        admitted = true;
+        startedAt = performance.now();
+        if (drainChunk) {
+          drainChunk();
+          return;
         }
-        const persistDrop = (mode) => {
-          let startedAt = 0;
-          try {
-            db.transaction(() => {
-              startedAt = performance.now();
-              markTagDropped2(db, sessionId, pendingOp.tagId, mode);
+        const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+        onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
+        const tags = preloadedTags ?? getTagsByNumbers2(db, sessionId, [
+          ...new Set([
+            ...pendingOps.map((op) => op.tagId),
+            ...syntheticPendingOps.map((op) => op.tagId)
+          ])
+        ]);
+        const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
+        const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
+        const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
+        const opsToApply = [
+          ...pendingOps.map((op) => ({ op, synthetic: false })),
+          ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
+        ];
+        diagnostics = {
+          source: pendingOps.length > 0 && syntheticPendingOps.length > 0 ? "mixed" : syntheticPendingOps.length > 0 ? "synthetic" : "pending",
+          total: opsToApply.length,
+          mutated: 0,
+          persistedWithoutMutation: 0,
+          reasons: {}
+        };
+        const skeletonWindow = new Set(preloadedTags ? tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW) : getNewestToolTagNumbers2(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
+        const plannedRemovals = new Set;
+        const removedTagIds = new Set;
+        const record = (mutated) => {
+          if (!diagnostics)
+            return;
+          if (mutated) {
+            didMutateMessage = true;
+            diagnostics.mutated += 1;
+          } else
+            diagnostics.persistedWithoutMutation += 1;
+        };
+        let cursor = 0;
+        drainChunk = () => {
+          const chunk = opsToApply.slice(cursor, cursor + PENDING_OPERATION_CHUNK_SIZE);
+          cursor += chunk.length;
+          hasMore = cursor < opsToApply.length;
+          for (const { op: pendingOp, synthetic } of chunk) {
+            const tagStatus = tagStatusById.get(pendingOp.tagId);
+            if (tagStatus === "compacted" || tagStatus === "dropped") {
+              reject("already_reduced");
               if (!synthetic)
                 removePendingOp(db, sessionId, pendingOp.tagId);
-            }).immediate();
-          } finally {
-            if (startedAt)
-              logSlowWriteTransaction("apply_pending_operation", startedAt);
-          }
-        };
-        let shouldPersistDrop = false;
-        if (isToolTag) {
-          if (editMarkerTagIds.has(pendingOp.tagId)) {
-            const strip = target?.hasAttachments?.() === true;
-            if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
-              reject("edit_marker_incomplete");
               continue;
             }
-            persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
-            const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
-            if (markResult === "incomplete" || markResult === "absent") {
-              reject(`edit_marker_${markResult}`);
+            if (removedTagIds.has(pendingOp.tagId)) {
+              reject("drop_incomplete");
               continue;
             }
-            didMutateMessage = true;
-            operationMutated = true;
-            onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "edit_marker" });
-            shouldPersistDrop = true;
-          } else {
-            const { result: dropResult, mode: appliedMode } = applyNewToolDrop(target, {
-              inWindow: skeletonWindow.has(pendingOp.tagId),
-              persist: persistDrop
-            });
-            if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
-              reject(`drop_${dropResult}`);
+            const target = targets.get(pendingOp.tagId);
+            const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
+            if (veto) {
+              reject(veto);
               continue;
             }
-            if (dropResult === "removed" || dropResult === "truncated") {
-              didMutateMessage = true;
-              operationMutated = true;
-              onTagReduced?.({
-                tagNumber: pendingOp.tagId,
-                mode: appliedMode === "full" ? "full" : "truncated"
+            const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
+            if (synthetic) {
+              if (!isToolTag) {
+                reject("synthetic_non_tool");
+                continue;
+              }
+              if (target?.canDrop?.() !== true) {
+                reject("synthetic_target_not_droppable");
+                continue;
+              }
+            }
+            const persistDrop = (mode) => {
+              markTagDropped2(db, sessionId, pendingOp.tagId, mode);
+              if (!synthetic)
+                removePendingOp(db, sessionId, pendingOp.tagId);
+            };
+            if (isToolTag) {
+              if (editMarkerTagIds.has(pendingOp.tagId)) {
+                const strip = target?.hasAttachments?.() === true;
+                if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
+                  reject("edit_marker_incomplete");
+                  continue;
+                }
+                persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
+                mutations.push(() => {
+                  const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
+                  if (markResult === "incomplete" || markResult === "absent") {
+                    reject(`edit_marker_${markResult}`);
+                    return;
+                  }
+                  record(true);
+                  onTagReduced?.({
+                    tagNumber: pendingOp.tagId,
+                    mode: "edit_marker"
+                  });
+                });
+              } else {
+                const plan = planNewToolDrop(target, { inWindow: skeletonWindow.has(pendingOp.tagId) }, true, plannedRemovals);
+                if (!plan) {
+                  reject("drop_incomplete");
+                  continue;
+                }
+                persistDrop(plan.mode);
+                if (plan.mode === "full" && target?.drop) {
+                  target.notePlannedRemoval?.(plannedRemovals);
+                  removedTagIds.add(pendingOp.tagId);
+                }
+                mutations.push(() => {
+                  const { result: dropResult, mode: appliedMode } = plan.apply();
+                  if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
+                    reject(`drop_${dropResult}`);
+                    return;
+                  }
+                  if (dropResult === "removed" || dropResult === "truncated") {
+                    record(true);
+                    onTagReduced?.({
+                      tagNumber: pendingOp.tagId,
+                      mode: appliedMode === "full" ? "full" : "truncated"
+                    });
+                  } else {
+                    reject(`drop_${dropResult}`);
+                    record(false);
+                  }
+                });
+              }
+            } else if (target) {
+              const replacement = buildReplacementContent(pendingOp.tagId);
+              persistDrop();
+              mutations.push(() => {
+                const priorContent = target.getContent?.();
+                const changed = target.setContent(replacement);
+                record(changed);
+                if (changed) {
+                  const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
+                  onTagReduced?.({
+                    tagNumber: pendingOp.tagId,
+                    mode: "partial",
+                    removedCharacters: Math.max(0, originalCharacters - replacement.length)
+                  });
+                } else {
+                  reject("content_unchanged");
+                }
               });
-            } else {
-              reject(`drop_${dropResult}`);
+            } else if (!synthetic) {
+              reject("target_absent");
+              persistDrop();
+              mutations.push(() => record(false));
             }
-            shouldPersistDrop = true;
-          }
-        } else if (target) {
-          const replacement = buildReplacementContent(pendingOp.tagId);
-          const priorContent = target.getContent?.();
-          persistDrop();
-          const changed = target.setContent(replacement);
-          if (changed) {
-            didMutateMessage = true;
-            operationMutated = true;
-            const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
-            onTagReduced?.({
-              tagNumber: pendingOp.tagId,
-              mode: "partial",
-              removedCharacters: Math.max(0, originalCharacters - replacement.length)
-            });
-          } else {
-            reject("content_unchanged");
           }
-          shouldPersistDrop = true;
-        } else if (!synthetic) {
-          reject("target_absent");
-          persistDrop();
-          shouldPersistDrop = true;
-        }
-        if (!shouldPersistDrop) {
-          reject("not_persisted");
-          continue;
-        }
-        if (operationMutated)
-          diagnostics.mutated += 1;
-        else
-          diagnostics.persistedWithoutMutation += 1;
+        };
+        drainChunk();
+      }).immediate();
+    } catch (error) {
+      if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
+        sessionLog2(sessionId, "pending operations write admission busy; retaining remaining operations for retry");
+        hasMore = false;
+      } else {
+        throw error;
       }
+    } finally {
+      if (startedAt)
+        logSlowWriteTransaction("apply_pending_operations", startedAt);
     }
-  } catch (error) {
-    if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
-      sessionLog2(sessionId, "pending operations write admission busy; retaining prior bytes for retry");
-      return false;
-    }
-    throw error;
-  }
+    for (const mutate of mutations.splice(0))
+      mutate();
+  } while (hasMore);
   if (diagnostics) {
     onBatchComplete?.(diagnostics);
     if (diagnostics.total > 0 && diagnostics.mutated === 0) {
@@ -8472,10 +8668,41 @@ function createExistingTagResolver(sessionId, tagger, db) {
 }
 
 // src/hooks/magic-context/transform-stage-logger.ts
-function logTransformTiming(sessionId, stage, startMs, extra) {
-  const elapsed = (performance.now() - startMs).toFixed(1);
+import { AsyncLocalStorage } from "node:async_hooks";
+var SLOW_STAGE_MS = 100;
+var passes = new AsyncLocalStorage;
+async function withTransformTimingSummary(run) {
+  const pass = {
+    stages: [],
+    slow: [],
+    closed: false,
+    sessionId: undefined
+  };
+  return passes.run(pass, async () => {
+    try {
+      return await run();
+    } finally {
+      pass.closed = true;
+      if (pass.sessionId)
+        sessionLog2(pass.sessionId, `transform stages: ${pass.stages.join(" ")} slow>=${SLOW_STAGE_MS}ms=[${pass.slow.join(",")}]`);
+    }
+  });
+}
+function logTransformElapsed(sessionId, stage, elapsedMs, extra) {
+  const elapsed = elapsedMs.toFixed(1);
   const suffix = extra ? ` ${extra}` : "";
-  sessionLog2(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
+  const pass = passes.getStore();
+  if (pass && !pass.closed) {
+    pass.sessionId = sessionId;
+    pass.stages.push(`${stage}=${elapsed}ms${extra ? `(${extra})` : ""}`);
+    if (elapsedMs >= SLOW_STAGE_MS)
+      pass.slow.push(stage);
+  }
+  if (elapsedMs >= SLOW_STAGE_MS)
+    sessionLog2(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
+}
+function logTransformTiming(sessionId, stage, startMs, extra) {
+  logTransformElapsed(sessionId, stage, performance.now() - startMs, extra);
 }
 
 // src/hooks/magic-context/tag-messages.ts
@@ -8841,13 +9068,18 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         }));
         accAssignTag += performance.now() - _tAssignText;
         const persistedSource = sourceContents.get(tagId);
-        if (persistedSource !== undefined) {
+        if (persistedSource !== undefined && !options.refreshSourceContents) {
           textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource) : persistedSource;
         } else {
           const sourceContent = stripTagPrefix(textPart.text);
-          if (sourceContent.trim().length > 0) {
+          if (sourceContent.trim().length > 0 || options.refreshSourceContents) {
             const _tSaveText = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
+            if (options.refreshSourceContents) {
+              replaceSourceContent(db, sessionId, tagId, sourceContent);
+              updateTagByteSize2(db, sessionId, tagId, byteSize(sourceContent));
+              updateTagTokenCount2(db, sessionId, tagId, estimateTextTagTokenCount(sourceContent));
+            } else
+              saveSourceContent(db, sessionId, tagId, sourceContent);
             accSaveSource += performance.now() - _tSaveText;
           }
         }
@@ -8940,7 +9172,10 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           const sourceContent = buildFileSourceContent(message.parts);
           if (sourceContent) {
             const _tSaveFile = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
+            if (options.refreshSourceContents)
+              replaceSourceContent(db, sessionId, tagId, sourceContent);
+            else
+              saveSourceContent(db, sessionId, tagId, sourceContent);
             accSaveSource += performance.now() - _tSaveFile;
           }
         }
@@ -9781,6 +10016,9 @@ async function runPostTransformPhase(args) {
     rewritingSignedPrefix = true;
     thinkingReleasedForFit ||= forFit;
   };
+  if (activeThinkingPrefixHold && args.forceSignedRebuildForFit) {
+    releaseThinkingForRewrite(true);
+  }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -9925,7 +10163,7 @@ async function runPostTransformPhase(args) {
   const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
-    hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
+    hardFold: rewritingSignedPrefix || foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
     publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
@@ -11184,6 +11422,26 @@ function systemPromptDates(prompt, sticky) {
   return { live: values.length ? JSON.stringify(values) : undefined, stable };
 }
 
+// src/hooks/magic-context/system-prompt-diagnostics.ts
+import { createHash } from "node:crypto";
+function snapshotSystemPrompt(system, preset) {
+  return { elements: system.map((element) => Buffer.from(element)), preset };
+}
+function describeSystemPromptChange(previous, current) {
+  const metadata = (element) => element === undefined ? "absent" : `bytes=${element.length},md5=${createHash("md5").update(element).digest("hex")}`;
+  const elements = [];
+  for (let index = 0;index < Math.max(previous?.elements.length ?? 0, current.elements.length); index++) {
+    const before = previous?.elements[index];
+    const after = current.elements[index];
+    let offset = 0;
+    while (before && after && offset < Math.min(before.length, after.length) && before[offset] === after[offset])
+      offset++;
+    const status = !previous ? "unknown" : !before ? "added" : !after ? "removed" : before.equals(after) ? "unchanged" : "changed";
+    elements.push(`${index}:${status}(${metadata(before)} -> ${metadata(after)},firstDiffByte=${!previous ? "unknown" : status === "unchanged" ? "none" : offset})`);
+  }
+  return `presetChanged=${previous ? previous.preset !== current.preset : "unknown"} elements=[${elements.join("; ")}]`;
+}
+
 // src/hooks/magic-context/system-date-refresh.ts
 var channels = new WeakMap;
 var outputUpdates = new WeakMap;
@@ -11341,6 +11599,7 @@ function createSystemPromptHashHandler(deps) {
   });
   const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
+  const diagnosticPrompts = new Map;
   const processSystemPrompt = async (input, output) => {
     const sessionId = input.sessionID;
     if (!sessionId)
@@ -11473,8 +11732,11 @@ function createSystemPromptHashHandler(deps) {
       return;
     }
     const sessionMeta = sessionMetaEarly;
+    const previousPrompt = diagnosticPrompts.get(sessionId);
+    const currentPrompt = previousPrompt && previousHash === currentHash ? previousPrompt : snapshotSystemPrompt(output.system, promptSurface.preset);
+    diagnosticPrompts.set(sessionId, currentPrompt);
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
-      sessionLog2(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : requestMessagesFinal ? "adopting on the request whose messages are already final" : "triggering flush"}`);
+      sessionLog2(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : requestMessagesFinal ? "adopting on the request whose messages are already final" : "triggering flush"}; ${describeSystemPromptChange(previousPrompt, currentPrompt)}`);
       noteSystemPromptHashChange(sessionId);
       if (!adoptSystemChange) {
         deps.historyRefreshSessions.add(sessionId);
@@ -11518,6 +11780,7 @@ function createSystemPromptHashHandler(deps) {
   return {
     handler,
     clearSession: (sessionId) => {
+      diagnosticPrompts.delete(sessionId);
       clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
@@ -11747,7 +12010,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/features/magic-context/memory/single-store-embedding-drain.ts
 function isWatermarkRow(row) {
@@ -11811,7 +12074,7 @@ function advanceEmbeddedWatermark(db, projectPath, upTo) {
 }
 
 // src/features/magic-context/mural/source-revision.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var statements = new WeakMap;
 function muralSourceRevision(db, projectPath) {
   let statement = statements.get(db);
@@ -11828,7 +12091,7 @@ function muralSourceRevision(db, projectPath) {
     statements.set(db, statement);
   }
   const row = statement.get(projectPath, Date.now());
-  return createHash("sha256").update(row.revision).digest("hex");
+  return createHash2("sha256").update(row.revision).digest("hex");
 }
 
 // src/features/magic-context/install-instance-id.ts
@@ -12255,6 +12518,7 @@ class HistorianHostRunner {
         throw new Error("hidden completion carrier returned no session id");
       const run = await promptSyncWithValidatedOutputRetry(undefined, {
         path: { id: handle.id },
+        cacheTail: "skip",
         query: { directory: sessionDirectory },
         body: {
           agent: "historian",
@@ -12285,6 +12549,7 @@ class HistorianHostRunner {
         timeoutMs: attemptMs,
         signal,
         fallbackModels: rest.map(withVariant),
+        allowModelSuggestions: false,
         callContext: `historian-host:${claim.runId}`,
         fetchOutput: () => withinAttempt(executor.collect(handle, 50), attemptStartedAt + attemptMs - Date.now(), attemptMs, signal).catch((error) => {
           recordAttempt(undefined, error);
@@ -14202,7 +14467,7 @@ function noteExternalLkgReplay(participant, sessionId, inputMessages, servedMess
 }
 
 // src/hooks/magic-context/rust-served-raw.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 class RustServedRawConflict extends EmergencyFailClosedError {
   reason;
   messageIds;
@@ -14216,7 +14481,7 @@ class RustServedRawConflict extends EmergencyFailClosedError {
 }
 function partDigest(part) {
   const serialized = JSON.stringify(part);
-  return createHash3("sha256").update(stableStringify(serialized === undefined ? undefined : JSON.parse(serialized))).digest("hex");
+  return createHash4("sha256").update(stableStringify(serialized === undefined ? undefined : JSON.parse(serialized))).digest("hex");
 }
 function records(doc) {
   if (doc.rustServedRaw === undefined)
@@ -14704,10 +14969,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)}:${createHash4("sha256").update(serializedMessage).digest("hex")}`;
+  return `${messageIdOf(message) ?? ""}:${parts.length}:${Buffer.byteLength(serializedParts)}:${createHash5("sha256").update(serializedMessage).digest("hex")}`;
 }
 function advanceWireFingerprint(previous, encoded) {
-  return createHash4("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
+  return createHash5("sha256").update(previous).update("\\0").update(JSON.stringify(encoded) ?? "null").digest("hex");
 }
 function buildWireFingerprint(encoded) {
   let fingerprint = "rust-wire-v1";
@@ -16488,7 +16753,7 @@ function createRustModeTransform(deps, options) {
         const id = messageIdOf(message) ?? `index:${todoStart + offset}`;
         const parts = message.parts?.filter((part) => isRecord4(part) && part.type === "tool" && part.tool === "todowrite");
         if (parts?.length) {
-          todoCalls.set(id, createHash4("sha256").update(JSON.stringify(parts)).digest("hex"));
+          todoCalls.set(id, createHash5("sha256").update(JSON.stringify(parts)).digest("hex"));
         } else {
           todoCalls.delete(id);
         }
@@ -18126,6 +18391,7 @@ function resolveTransformHostSeams(deps) {
     hostRefuse: deps.hostRefuse ?? abortSessionFailClosed
   };
 }
+var SIGNED_FIT_REFUSED_MARKER = "signed_fit:refused:v1";
 function createTransform(deps) {
   registerSystemDateRefresh(deps.historyRefreshSessions);
   const finalWireUsage = createFinalWireUsageTracker();
@@ -18799,7 +19065,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       const tagged = tagMessages(sessionId, tail, deps.tagger, db, {
         skipPrefixInjection: !ctxReduceCallable,
         servedMessages: messages,
-        normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText
+        normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText,
+        refreshSourceContents: deps.refreshSourceContents?.(sessionId)
       });
       for (const [number, target] of tagged.targets)
         targets.set(number, target);
@@ -18824,7 +19091,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           skipPrefixInjection,
           scopedToolSweep,
           servedMessages: messages,
-          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText
+          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText,
+          refreshSourceContents: deps.refreshSourceContents?.(sessionId)
         });
         targets = result.targets;
         if (thinkingRecovery.restore)
@@ -19047,7 +19315,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const protectedTagIds = protectedTagNumbers;
     const protectedCutoff = protectionWindow.cutoff;
     const tPostProcess = performance.now();
-    dropProjectionEmergency = thinkingFitRetries.has(sessionId) || contextUsage.percentage >= 95;
+    dropProjectionEmergency = contextUsage.percentage >= 95;
     const postTransformResult = await runPostTransformPhase({
       opencode2: deps.storeGeneration === "v2",
       normalizeRecoveryTail,
@@ -19066,7 +19334,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       client: deps.client,
       activeAgent,
       batch,
-      contextUsage: thinkingFitRetries.has(sessionId) ? { ...contextUsage, percentage: Math.max(95, contextUsage.percentage) } : contextUsage,
+      contextUsage,
       usableWindow: resolvedContextLimit ?? 0,
       schedulerDecision,
       schedulerDeferReason,
@@ -19151,6 +19419,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       postTransformResult.bustedThisPass = true;
     passOutcome.markFinalized();
     const finalWireTail = describeFinalWireTail(messages);
+    const signedFitPreviouslyRefused = !compactionOff && getMergedReasoningStrippedIds(db, sessionId).has(SIGNED_FIT_REFUSED_MARKER);
     let finalWireEstimate;
     if (postTransformResult.bustedThisPass) {
       try {
@@ -19168,7 +19437,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     }
     if (!compactionOff) {
       const emergencyUsagePercentage = usagePercentageSynthetic ? Math.max(95, contextUsage.percentage) : windowGeometry?.usableHard && contextUsage.inputTokens > 0 ? contextUsage.inputTokens / windowGeometry.usableHard * 100 : contextUsage.percentage;
-      finalWireEstimate = finalWireEstimate ?? (emergencyUsagePercentage >= 95 || schedulerDecision === "execute" ? finalWireUsage.estimate(sessionId, {
+      finalWireEstimate = finalWireEstimate ?? (emergencyUsagePercentage >= 95 || schedulerDecision === "execute" || signedFitPreviouslyRefused ? finalWireUsage.estimate(sessionId, {
         messages,
         systemPromptTokens: sessionMeta.systemPromptTokens,
         providerID: modelForBudget?.providerID,
@@ -19191,8 +19460,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           }
           return;
         }
-        if (thinkingFitRetries.has(sessionId) || postTransformResult.thinkingReleasedForFit)
+        if (thinkingFitRetries.has(sessionId) || postTransformResult.thinkingReleasedForFit || signedFitPreviouslyRefused) {
+          if (!signedFitPreviouslyRefused && !addMergedReasoningStrippedIds(db, sessionId, [SIGNED_FIT_REFUSED_MARKER]))
+            throw contextRefusalError("Cannot persist the signed-fit refusal");
           throw contextRefusalError("The request remains over the model window after stripping signed thinking and reclaiming context");
+        }
       }
       if (postTransformResult.prefixTrimStatus === "refused") {
         const untrimmed = finalWireEstimate ?? estimateFinalWireInputTokens({
@@ -19504,7 +19776,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         systemPromptHash: sessionMeta.systemPromptHash
       });
   };
-  return Object.assign(transform, {
+  const timedTransform = (input, output) => withTransformTimingSummary(() => transform(input, output));
+  return Object.assign(timedTransform, {
     clearSessionLogState,
     invalidateRustWireState(sessionId) {
       rustModeTransform?.invalidateWireState(sessionId);
@@ -21171,7 +21444,7 @@ function computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry) {
 import { readFileSync, statSync } from "node:fs";
 
 // src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -21219,7 +21492,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix(value, length = 16) {
-  return createHash5("sha256").update(value).digest("hex").slice(0, length);
+  return createHash6("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -22726,8 +22999,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-5zhxtwha.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-8ghn9tnv.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-cmqnfpp3.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-3pxn658x.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -22811,7 +23084,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-65pwye0d.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-xs8redz9.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -23183,7 +23456,58 @@ function readOmoDisabledHooks(directory) {
 
 // src/shared/rpc-server.ts
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { readdirSync, readFileSync as readFileSync4, unlinkSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync4, rmdirSync, unlinkSync } from "node:fs";
+
+// src/shared/rpc-discovery-cleanup.ts
+import { promises as fs } from "node:fs";
+import { join as join6 } from "node:path";
+async function reapDeadRpcDiscovery(storageDir) {
+  const root = join6(storageDir, "rpc");
+  let directories;
+  try {
+    directories = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const records = [];
+  const projectDirs = [];
+  for (const entry of directories) {
+    if (!entry.isDirectory() || !/^[0-9a-f]{16}$/.test(entry.name))
+      continue;
+    const directory = join6(root, entry.name);
+    projectDirs.push(directory);
+    try {
+      for (const name of await fs.readdir(directory)) {
+        const match = /^port-(\d+)(?:-[0-9a-f]+)?\.json$/.exec(name);
+        if (!match)
+          continue;
+        const path = join6(directory, name);
+        try {
+          const content = await fs.readFile(path, "utf8");
+          const record = parseRpcPortFile(content, Number(match[1]));
+          if (record && record.pid === Number(match[1]))
+            records.push({ path, content, pid: record.pid });
+        } catch {}
+      }
+    } catch {}
+  }
+  const processes = records.length ? await inspectProcessesAsync(true) : undefined;
+  for (const record of records) {
+    if (processes?.liveness(record.pid) !== "dead")
+      continue;
+    try {
+      if (await fs.readFile(record.path, "utf8") === record.content)
+        await fs.unlink(record.path);
+    } catch {}
+  }
+  for (const directory of projectDirs) {
+    try {
+      await fs.rmdir(directory);
+    } catch {}
+  }
+}
+
+// src/shared/rpc-server.ts
 var MAX_BODY_BYTES = 1048576;
 var WS_AUTH_TIMEOUT_MS = 5000;
 var WS_CLOSE_UNAUTHORIZED = 4401;
@@ -23206,17 +23530,20 @@ function websocketToken(req) {
 }
 
 class MagicContextRpcServer {
+  storageDir;
   server = null;
   port = 0;
   handlers = new Map;
   portFilePath;
   portDir;
   startedAt = Date.now();
+  stopped = false;
   instanceId = randomBytes(8).toString("hex");
   unregisterOwnInstance = null;
   sockets = new Set;
   token = randomBytes(32).toString("hex");
   constructor(storageDir, directory) {
+    this.storageDir = storageDir;
     this.portFilePath = rpcPortFilePath(storageDir, directory, process.pid, this.instanceId);
     this.portDir = rpcPortDir(storageDir, directory);
   }
@@ -23234,6 +23561,10 @@ class MagicContextRpcServer {
       log2("rpc server skipped: Bun runtime not available (no TUI consumer)");
       return 0;
     }
+    this.stopped = false;
+    await reapDeadRpcDiscovery(this.storageDir);
+    if (this.stopped)
+      return 0;
     this.startedAt = Date.now();
     const self = this;
     const server = inRootAsyncContext2(() => Bun.serve({
@@ -23265,7 +23596,7 @@ class MagicContextRpcServer {
     try {
       this.warnIfOtherLiveInstance();
       this.unregisterOwnInstance ??= registerOwnRpcServerInstance(this.instanceId);
-      writeStorageFileAtomicSync(this.portFilePath, JSON.stringify({
+      const publish = () => writeStorageFileAtomicSync(this.portFilePath, JSON.stringify({
         port: this.port,
         pid: process.pid,
         started_at: this.startedAt,
@@ -23273,6 +23604,13 @@ class MagicContextRpcServer {
         token: this.token,
         instance_id: this.instanceId
       }));
+      try {
+        publish();
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+        publish();
+      }
       log2(`[rpc] server listening on 127.0.0.1:${this.port}`);
     } catch (err) {
       log2(`[rpc] failed to write port file: ${err}`);
@@ -23280,6 +23618,7 @@ class MagicContextRpcServer {
     return this.port;
   }
   stop() {
+    this.stopped = true;
     for (const ws of this.sockets) {
       try {
         if (ws.data.authTimer)
@@ -23296,6 +23635,9 @@ class MagicContextRpcServer {
     try {
       unlinkSync(this.portFilePath);
     } catch {}
+    try {
+      rmdirSync(this.portDir);
+    } catch {}
     this.unregisterOwnInstance?.();
     this.unregisterOwnInstance = null;
   }
@@ -23800,8 +24142,8 @@ function hostMediaFromEncoded(value) {
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/v2/fold/owner.ts
-import { createHash as createHash6 } from "node:crypto";
-var foldDigest = (value) => createHash6("sha256").update(value).digest("hex");
+import { createHash as createHash7 } from "node:crypto";
+var foldDigest = (value) => createHash7("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -24720,24 +25062,31 @@ ${data.output?.output ?? ""}`
   const sameModel = sameProvider && previousModel?.id === model.id;
   const reuse = sameModel && data.error === undefined;
   const metadata = (state) => state === undefined ? undefined : { [model.providerID]: state };
+  const reasoningInterrupted = data.content?.some((part) => part.type === "reasoning" && part.time !== undefined && part.time.completed === undefined);
   const content = [];
   const results = [];
   for (const part of data.content ?? []) {
+    let native = "native" in part ? part.native : part.type === "tool" ? part.providerState : part.state;
+    if (part.type === "tool" && part.providerResultState !== null && typeof part.providerResultState === "object" && !Array.isArray(part.providerResultState))
+      native = {
+        ...native !== null && typeof native === "object" && !Array.isArray(native) ? native : {},
+        ...part.providerResultState
+      };
     if (part.type === "text") {
       if (part.text !== "")
         content.push({
           type: "text",
           text: part.text,
-          providerMetadata: reuse ? metadata(part.state) : undefined
+          providerMetadata: reuse ? metadata(native) : undefined
         });
       continue;
     }
     if (part.type === "reasoning") {
-      if (part.text !== "" || reuse && part.state !== undefined)
+      if (part.text !== "" || reuse && !reasoningInterrupted && native !== undefined)
         content.push({
-          type: reuse || data.error === undefined ? "reasoning" : "text",
+          type: data.error === undefined && !reasoningInterrupted ? "reasoning" : "text",
           text: part.text,
-          providerMetadata: reuse ? metadata(part.state) : undefined
+          providerMetadata: reuse && !reasoningInterrupted ? metadata(native) : undefined
         });
       continue;
     }
@@ -24756,7 +25105,7 @@ ${data.output?.output ?? ""}`
       name: part.name,
       input,
       providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
+      providerMetadata: toolReuse ? metadata(native) : undefined
     });
     if (!completed)
       continue;
@@ -24767,7 +25116,7 @@ ${data.output?.output ?? ""}`
       id: part.id,
       name: part.name,
       providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : undefined,
+      providerMetadata: (part.executed === true ? sameProvider : reuse) ? metadata(native) : undefined,
       result: state.status === "error" ? { error: state.error, content: toolContent } : single?.type === "text" ? { type: "text", value: single.text } : { type: "content", value: toolContent },
       ...state.status === "error" ? { resultType: "error" } : {}
     };
@@ -24795,13 +25144,50 @@ function copyNativeInput(messages) {
   return copies;
 }
 function isLocalCheckpoint(row) {
-  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined;
+  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined && row.data.native?.messages === undefined;
+}
+function isAdmittedLocalCheckpoint(storage, sessionID, cut) {
+  if (!isLocalCheckpoint(cut) || cut.session_id !== sessionID)
+    return false;
+  const admission = storage.admission(sessionID, cut.id);
+  if (!admission?.payload || admission.digest !== foldDigest(admission.payload))
+    return false;
+  try {
+    const snapshot = JSON.parse(admission.payload);
+    return snapshot.source === storage.sourceID && snapshot.sessionID === sessionID && snapshot.admissionID === cut.id && snapshot.summary === cut.data.summary;
+  } catch {
+    return false;
+  }
 }
 var conversational = (row) => RAW_MESSAGE_TYPES.includes(row.type) || row.type === "location-switched";
+var historyDigest = (reader, sessionID, through) => foldDigest(JSON.stringify(reader.range(sessionID, -1, through).filter(conversational)));
+var admissionKey = (sessionID) => `native-fold/v2/${encodeURIComponent(sessionID)}`;
+async function forgetNativeFoldProvenance(storage, sessionID, legacyOnly = false) {
+  const remove = async (key) => {
+    if (storage.remove)
+      await storage.remove(key);
+    else
+      await storage.set(key, null);
+  };
+  if (!legacyOnly)
+    await remove(admissionKey(sessionID));
+  if (!storage.scan)
+    return;
+  let after;
+  do {
+    const page = await storage.scan({ prefix: "native-fold/v1/", after, limit: 100 });
+    for (const { key } of page.entries) {
+      if (key.slice("native-fold/v1/".length).split("/").slice(1).join("/") === sessionID)
+        await remove(key);
+    }
+    after = page.next;
+  } while (after);
+}
 
 class NativeFoldReplay {
   storage;
   openReader;
+  admissions;
   changed = new Set;
   dirty = new Set;
   unavailable = new Set;
@@ -24809,9 +25195,11 @@ class NativeFoldReplay {
   metadataThrough = new Map;
   loaded = new Map;
   sources = new Map;
-  constructor(storage, openReader) {
+  staleHeads = new Set;
+  constructor(storage, openReader, admissions) {
     this.storage = storage;
     this.openReader = openReader;
+    this.admissions = admissions;
     storage.onEvict((sessionID) => this.clear(sessionID));
   }
   account(sessionID) {
@@ -24850,6 +25238,51 @@ class NativeFoldReplay {
   async baseline(sessionID) {
     return this.tail(sessionID)?.baseline;
   }
+  admissionKey(sessionID) {
+    return admissionKey(sessionID);
+  }
+  async removeAdmission(key) {
+    if (this.admissions?.remove)
+      await this.admissions.remove(key);
+    else
+      await this.admissions?.set(key, null);
+  }
+  async removeLegacyAdmissions(sessionID) {
+    if (this.admissions)
+      await forgetNativeFoldProvenance(this.admissions, sessionID, true);
+  }
+  async admits(sessionID, cut, reader) {
+    if (!isLocalCheckpoint(cut) || cut.session_id !== sessionID)
+      return false;
+    if (isAdmittedLocalCheckpoint(this.storage, sessionID, cut))
+      return true;
+    if (!this.admissions)
+      return false;
+    try {
+      const source = reader.hostIdentity();
+      const saved = await this.admissions.get(this.admissionKey(sessionID));
+      if (!saved?.payload || saved.digest !== foldDigest(saved.payload))
+        return false;
+      const snapshot = JSON.parse(saved.payload);
+      if (snapshot.sourceDigest !== foldDigest(source) || snapshot.sessionID !== sessionID || snapshot.admissionID !== cut.id || snapshot.summaryDigest !== foldDigest(cut.data.summary ?? ""))
+        return false;
+      if (snapshot.historyDigest !== historyDigest(reader, sessionID, cut.seq - 1)) {
+        this.staleHeads.add(sessionID);
+        this.invalidate(sessionID);
+        await this.removeAdmission(this.admissionKey(sessionID));
+        return false;
+      }
+      await this.storage.supply(sessionID, cut.id, JSON.stringify({
+        source: this.storage.sourceID,
+        sessionID,
+        admissionID: cut.id,
+        summary: cut.data.summary
+      }));
+      return true;
+    } catch {
+      return false;
+    }
+  }
   rendered(row, model) {
     return restoreRow(row, model, hostUsesMediaAssets() ? {
       asset: hostMediaAsset,
@@ -24927,6 +25360,7 @@ class NativeFoldReplay {
         this.loaded.set(draft.sessionID, through);
         this.unavailable.delete(draft.sessionID);
         this.changed.delete(draft.sessionID);
+        this.staleHeads.delete(draft.sessionID);
       } finally {
         reader.close();
       }
@@ -24953,7 +25387,8 @@ class NativeFoldReplay {
   async supplyHeld(args) {
     const { draft, reader, summary } = args;
     const tail = this.tail(draft.sessionID);
-    const id = reader.latestRunningCompaction(draft.sessionID)?.id;
+    const running = reader.latestRunningCompaction(draft.sessionID);
+    const id = running?.id;
     if (!id || !tail || tail.model !== `${draft.model.providerID}/${draft.model.id}`)
       return false;
     const through = reader.latestSequence(draft.sessionID);
@@ -24977,6 +25412,21 @@ class NativeFoldReplay {
       summary
     };
     await this.storage.supply(draft.sessionID, id, JSON.stringify(snapshot));
+    if (this.admissions) {
+      const provenance = {
+        sourceDigest: foldDigest(reader.hostIdentity()),
+        sessionID: draft.sessionID,
+        admissionID: id,
+        summaryDigest: foldDigest(summary),
+        historyDigest: historyDigest(reader, draft.sessionID, (running?.seq ?? through) - 1)
+      };
+      const payload = JSON.stringify(provenance);
+      await this.admissions.set(this.admissionKey(draft.sessionID), {
+        payload,
+        digest: foldDigest(payload)
+      });
+      await this.removeLegacyAdmissions(draft.sessionID);
+    }
     return true;
   }
   async restore(sessionID, cut, model, options = {}) {
@@ -25061,6 +25511,9 @@ class NativeFoldReplay {
   sourceChanged(sessionID) {
     return this.changed.has(sessionID);
   }
+  needsHeadRebuild(sessionID) {
+    return this.staleHeads.has(sessionID);
+  }
   clear(sessionID) {
     this.sources.delete(sessionID);
     this.metadata.delete(sessionID);
@@ -25069,8 +25522,11 @@ class NativeFoldReplay {
     this.unavailable.delete(sessionID);
     this.dirty.delete(sessionID);
     this.changed.delete(sessionID);
+    this.staleHeads.delete(sessionID);
   }
   async forget(sessionID) {
+    if (this.admissions)
+      await forgetNativeFoldProvenance(this.admissions, sessionID);
     await this.storage.forget(sessionID);
   }
 }
@@ -25085,11 +25541,7 @@ class HostFoldPolicy {
     this.deps = deps;
   }
   owned(sessionID, cut, id) {
-    const row = this.deps.storage.admission(sessionID, id);
-    if (!isLocalCheckpoint(cut) || cut.id !== id || !row?.payload || row.digest !== foldDigest(row.payload))
-      return false;
-    const snapshot = JSON.parse(row.payload);
-    return snapshot.summary === cut.data.summary && snapshot.source === this.deps.storage.sourceID && snapshot.sessionID === sessionID && snapshot.admissionID === id;
+    return cut.id === id && isAdmittedLocalCheckpoint(this.deps.storage, sessionID, cut);
   }
   async idle(sessionID) {
     const { storage, session, threshold } = this.deps;
@@ -25512,7 +25964,7 @@ async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
 // src/shared/models-dev-temperature.ts
 import { readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var CATALOG_PROVIDER_ALIASES = {
   "google-antigravity": "google",
   "opencode-zen": "opencode"
@@ -25522,7 +25974,7 @@ var cached;
 function modelsDevCatalogPath(env = process.env) {
   if (env.OPENCODE_MODELS_PATH)
     return env.OPENCODE_MODELS_PATH;
-  return join6(env.XDG_CACHE_HOME || join6(homedir3(), ".cache"), "opencode", "models.json");
+  return join7(env.XDG_CACHE_HOME || join7(homedir3(), ".cache"), "opencode", "models.json");
 }
 function buildIndex(raw) {
   const index = new Map;
@@ -26520,11 +26972,11 @@ class DeletedSessionTombstones {
 }
 
 // src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
 
 // src/features/magic-context/mural/compress-cues.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 
 // src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
@@ -27267,7 +27719,7 @@ async function applyCuesThroughModule(args, chunk, manifestText, signal) {
       log2(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
     }
   }
-  const commandId = `mural-cues:${route.moduleCommandId}:${createHash7("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `mural-cues:${route.moduleCommandId}:${createHash8("sha256").update(chunk.map((candidate) => candidate.memory.id).join(",")).digest("hex").slice(0, 24)}`;
   let response;
   try {
     response = await route.moduleClient.call({
@@ -27870,7 +28322,7 @@ function applyReviewVerdict(args, leaseKey, parsed, result) {
 }
 
 // src/features/magic-context/dreamer/classify.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // src/plugin/rust-tool-backends.ts
 function isRustAuthorityDrainingError(error) {
@@ -28307,7 +28759,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal, runOnHost)
     if (entry.qualifier)
       modelVariants[entry.model] = entry.qualifier;
   }
-  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash8("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`;
+  const commandId = `classify:${args.moduleCommandId ?? Date.now()}:${createHash9("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`;
   const runTask = (hostCompletion) => args.moduleClient?.call({
     sessionId: args.moduleSessionId,
     projectRoot: args.moduleProjectRoot,
@@ -28582,7 +29034,7 @@ function takeCurateSafetyRefusalCount(sessionId) {
 
 // src/features/magic-context/dreamer/docs-proposals.ts
 import { execFileSync } from "node:child_process";
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import {
   existsSync as existsSync4,
   mkdirSync,
@@ -28595,19 +29047,19 @@ import {
   writeFileSync
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 var FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
-var hash = (text) => createHash9("sha256").update(text).digest("hex");
-var proposalDir = (projectDir) => join7(projectDir, ".cortexkit/magic-context/docs-update-proposals");
+var hash = (text) => createHash10("sha256").update(text).digest("hex");
+var proposalDir = (projectDir) => join8(projectDir, ".cortexkit/magic-context/docs-update-proposals");
 function docsBaseHashes(projectDir) {
   return Object.fromEntries(FILES.map((name) => [
     name,
-    hash(existsSync4(join7(projectDir, name)) ? readFileSync6(join7(projectDir, name), "utf8") : "")
+    hash(existsSync4(join8(projectDir, name)) ? readFileSync6(join8(projectDir, name), "utf8") : "")
   ]));
 }
 function listPendingDocsProposals(projectDir) {
   const dir = proposalDir(projectDir);
-  return existsSync4(dir) ? readdirSync2(dir).filter((name) => name.endsWith(".md")).sort().map((name) => join7(dir, name)) : [];
+  return existsSync4(dir) ? readdirSync2(dir).filter((name) => name.endsWith(".md")).sort().map((name) => join8(dir, name)) : [];
 }
 function hasCurrentDocsProposal(projectDir) {
   const hashes = docsBaseHashes(projectDir);
@@ -28665,7 +29117,7 @@ function docsChangeSet(projectDir, storedAnchor) {
       const files = [
         ...new Set(changed.flat().filter((file) => file !== "ARCHITECTURE.md" && file !== "STRUCTURE.md" && !/(?:^|[./-])(test|spec)(?:[./-]|$)/.test(file) && !file.endsWith(".lock")))
       ];
-      const docs = FILES.map((file) => existsSync4(join7(projectDir, file)) ? readFileSync6(join7(projectDir, file), "utf8") : "").join(`
+      const docs = FILES.map((file) => existsSync4(join8(projectDir, file)) ? readFileSync6(join8(projectDir, file), "utf8") : "").join(`
 `);
       const relevant = files.some((file) => {
         const directory = file.split("/").slice(0, -1).join("/");
@@ -28793,14 +29245,14 @@ function protectedBytes(text) {
   ].map((match) => match[0]);
 }
 function diff(name, before, after) {
-  const dir = mkdtempSync(join7(tmpdir(), "mc-doc-diff-"));
+  const dir = mkdtempSync(join8(tmpdir(), "mc-doc-diff-"));
   try {
-    writeFileSync(join7(dir, "before"), before);
-    writeFileSync(join7(dir, "after"), after);
+    writeFileSync(join8(dir, "before"), before);
+    writeFileSync(join8(dir, "after"), after);
     try {
-      return execFileSync("git", ["diff", "--no-index", "--", join7(dir, "before"), join7(dir, "after")], { windowsHide: true, encoding: "utf8" });
+      return execFileSync("git", ["diff", "--no-index", "--", join8(dir, "before"), join8(dir, "after")], { windowsHide: true, encoding: "utf8" });
     } catch (error) {
-      return error.stdout?.replaceAll(join7(dir, "before"), `a/${name}`).replaceAll(join7(dir, "after"), `b/${name}`) ?? "";
+      return error.stdout?.replaceAll(join8(dir, "before"), `a/${name}`).replaceAll(join8(dir, "after"), `b/${name}`) ?? "";
     }
   } finally {
     rmSync2(dir, { recursive: true, force: true });
@@ -28821,7 +29273,7 @@ function validateDocsProposal(projectDir, output, budget, expected) {
   let tokens = 0;
   let diffs = "";
   for (const file of FILES) {
-    const before = existsSync4(join7(projectDir, file)) ? readFileSync6(join7(projectDir, file), "utf8") : "";
+    const before = existsSync4(join8(projectDir, file)) ? readFileSync6(join8(projectDir, file), "utf8") : "";
     let after = before;
     const seen = new Set;
     for (const change of changes.filter((item) => item.file === file)) {
@@ -28871,9 +29323,9 @@ ${change.text.trimEnd()}
 function writeDocsProposal(projectDir, output, budget, expected, head) {
   const result = validateDocsProposal(projectDir, output, budget, expected);
   const dir = proposalDir(projectDir);
-  mkdirSync(join7(dir, "superseded"), { recursive: true });
+  mkdirSync(join8(dir, "superseded"), { recursive: true });
   const stamp = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
-  const path = join7(dir, `${stamp}.md`);
+  const path = join8(dir, `${stamp}.md`);
   const body = `# Docs update proposal
 
 Base commit: ${head}
@@ -28901,7 +29353,7 @@ ${result.diffs}
   writeFileSync(path, body, { flag: "wx" });
   for (const old of listPendingDocsProposals(projectDir))
     if (old !== path)
-      renameSync(old, join7(dir, "superseded", old.split("/").at(-1) ?? "proposal.md"));
+      renameSync(old, join8(dir, "superseded", old.split("/").at(-1) ?? "proposal.md"));
   return path;
 }
 
@@ -29133,7 +29585,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // src/features/magic-context/smart-notes/compiler-prompt.ts
 var SMART_NOTE_COMPILER_SYSTEM_PROMPT = `You are the Magic Context smart-note compiler for the magic-context system.
@@ -29472,7 +29924,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash10("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash11("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
 }
 function extractJsonObject(output) {
   const fenced = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -29550,7 +30002,7 @@ function deterministicJitterMs(intervalMs, noteId, hash) {
 }
 
 // src/features/magic-context/smart-notes/wake-plane.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var WAKE_PLANE_CAPABILITY = "wake.create";
 var WAKE_PLANE_STATUS_TTL_MS = 5 * 60 * 1000;
 var WAKE_PLANE_HANDSHAKE_TIMEOUT_MS = 2000;
@@ -29559,7 +30011,7 @@ var inFlightProbe = null;
 var catalogProbe = probeWakePlaneCatalog;
 var now = () => Date.now();
 function connectionFile() {
-  return join8(getDataDir(), "cortexkit", "run", "subc-connection.json");
+  return join9(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 async function probeWakePlaneCatalog() {
   const file = connectionFile();
@@ -30222,12 +30674,12 @@ async function archiveExpiredMemories(args) {
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 import { existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var MAINTAIN_DOCS_SNAPSHOT_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function snapshotMaintainDocsFiles(docsDir) {
   const snapshot = new Map;
   for (const name of MAINTAIN_DOCS_SNAPSHOT_FILES) {
-    const path = join9(docsDir, name);
+    const path = join10(docsDir, name);
     try {
       if (existsSync5(path)) {
         snapshot.set(name, readFileSync7(path, "utf8"));
@@ -30238,7 +30690,7 @@ function snapshotMaintainDocsFiles(docsDir) {
 }
 
 // src/features/magic-context/dreamer/map-memories.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -30473,7 +30925,7 @@ function readRetries(db, project) {
   }
 }
 function contentKey2(memory) {
-  return createHash11("sha256").update(`${memory.category}
+  return createHash12("sha256").update(`${memory.category}
 ${memory.content}`).digest("hex");
 }
 function isDeferred(memory, retries) {
@@ -30895,7 +31347,7 @@ async function applyParsedBatchMappings(args, batch, parsed, budgetFinalized = f
           name: "memory.set_mapping",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash11("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash12("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -32196,7 +32648,7 @@ function insertDreamRun(db, run) {
 }
 
 // src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 
 // src/features/magic-context/dreamer/verify-diff.ts
 import { execFile as execFile3 } from "node:child_process";
@@ -33061,7 +33513,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           name: "memory.set_verification",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash12("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash13("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -33895,7 +34347,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash13("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash14("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -35333,7 +35785,7 @@ function runTick(origin) {
   if (tickInFlight)
     return;
   tickInFlight = true;
-  log2(`[dreamer] timer tick (${origin}) — projects=${registeredProjects.size}`);
+  log2(`[magic-context] maintenance tick (${origin}) — projects=${registeredProjects.size}`);
   (async () => {
     try {
       const db = openTimerDatabaseOrNull("maintenance tick");
@@ -35383,6 +35835,9 @@ function persistTickOutcome(db, failure) {
   }
 }
 async function runMessageHistoryMaintenance(db) {
+  const prunedIdentities = await pruneMissingProjectIdentities();
+  if (prunedIdentities > 0)
+    log2(`[magic-context] pruned ${prunedIdentities} missing project identities`);
   try {
     await drainStaleLkgSlots(db);
   } catch (error) {
@@ -35616,10 +36071,20 @@ async function sweepGitCommits(args) {
   const holderId = crypto.randomUUID();
   const lease = acquireGitSweepLease(db, projectIdentity, holderId);
   if (!lease.acquired) {
-    const reason = lease.reason === "cooldown_active" ? `cooldown active until ${lease.nextAllowedAt}` : `lease held by ${lease.leaseHolder ?? "another holder"} until ${lease.leaseExpiresAt ?? "unknown"}`;
+    if (lease.reason === "cooldown_active")
+      return;
+    const reason = `lease held by ${lease.leaseHolder ?? "another holder"} until ${lease.leaseExpiresAt ?? "unknown"}`;
     log2(`[git-commits] sweep skipped for ${projectIdentity}: ${reason}`);
     return;
   }
+  if (projectIdentity.startsWith("dir:")) {
+    if (parkGitSweepNonIndexable(db, projectIdentity, holderId)) {
+      log2(`[git-commits] sweep parked for ${projectIdentity}: directory identity has no commits`);
+    } else {
+      releaseGitSweepLease(db, projectIdentity, holderId);
+    }
+    return;
+  }
   const startedAt = Date.now();
   const stopRenewal = startGitSweepLeaseRenewal(db, projectIdentity, holderId);
   log2(`[git-commits] sweep starting for ${projectIdentity} (sinceDays=${gitCommitIndexing.since_days} maxCommits=${gitCommitIndexing.max_commits})`);
@@ -35880,9 +36345,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function identity(slot) {
-  return createHash14("sha256").update(JSON.stringify({
+  return createHash15("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -48710,7 +49175,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -48934,61 +49399,11 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord6(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord6(part) && typeof part.text === "string" && createHash15("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord6(part) && typeof part.text === "string" && createHash16("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."),
@@ -49022,7 +49437,7 @@ function createCtxExpandTool(deps) {
         return renderItemByTag(deps.db, sessionId, mode.tag);
       }
       if (mode.kind === "message") {
-        return renderSearchArchive(deps.db, sessionId, mode.message, mode.message, CTX_EXPAND_TOKEN_BUDGET) ?? renderMessageByOrdinal(sessionId, mode.message);
+        return await renderSearchArchiveOffThread2(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);
@@ -49030,7 +49445,7 @@ 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);
+      const archived = await renderSearchArchiveOffThread2(deps.db, sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
       if (archived)
         return archived;
       if (verbose) {
@@ -49739,7 +50154,7 @@ import { isAbsolute as isAbsolute2 } from "node:path";
 // ../retina-local-fs/src/path-fence.ts
 import { lstat as lstat2, realpath as realpath2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { basename, dirname as dirname2, isAbsolute, join as join10, relative, resolve as resolve2, sep } from "node:path";
+import { basename, dirname as dirname2, isAbsolute, join as join11, relative, resolve as resolve2, sep } from "node:path";
 
 // ../retina-local-fs/src/errors.ts
 class ProviderError extends Error {
@@ -49754,7 +50169,7 @@ class ProviderError extends Error {
 // ../retina-local-fs/src/path-fence.ts
 async function resolveAndFenceProviderPath(configuredPath, options) {
   const { home, dataDirectory, aliases } = await resolveFenceRoots(options);
-  const expanded = configuredPath.startsWith("~/") ? join10(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
+  const expanded = configuredPath.startsWith("~/") ? join11(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
   const absolute = isAbsolute(expanded) ? resolve2(expanded) : resolve2(options.cwd ?? process.cwd(), expanded);
   const canonical = await canonicalPath(absolute, options.allowMissing);
   if (fenceCandidates(canonical, aliases).some((candidate) => isFencedPath(candidate, home, dataDirectory))) {
@@ -49771,13 +50186,13 @@ async function resolveFenceRoots(options) {
   } catch (error) {
     throw fsError(configuredHomePath, error);
   }
-  const configuredDataDirectory = resolve2(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join10(home, ".local", "share"));
+  const configuredDataDirectory = resolve2(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join11(home, ".local", "share"));
   const dataDirectory = await canonicalPath(configuredDataDirectory, true);
   const aliases = [];
-  const logicalCortexkit = join10(dataDirectory, "cortexkit");
+  const logicalCortexkit = join11(dataDirectory, "cortexkit");
   for (const logical of [
     logicalCortexkit,
-    ...FENCED_CORTEXKIT_ROOTS.map((root) => join10(logicalCortexkit, root))
+    ...FENCED_CORTEXKIT_ROOTS.map((root) => join11(logicalCortexkit, root))
   ]) {
     const canonical = await canonicalPath(logical, true);
     if (canonical !== logical)
@@ -49791,7 +50206,7 @@ function fenceCandidates(canonical, aliases) {
     const relativeToAlias = relative(alias.canonical, canonical);
     const inside = relativeToAlias === "" || relativeToAlias !== ".." && !relativeToAlias.startsWith(`..${sep}`) && !isAbsolute(relativeToAlias);
     if (inside)
-      candidates.push(join10(alias.logical, relativeToAlias));
+      candidates.push(join11(alias.logical, relativeToAlias));
   }
   return candidates;
 }
@@ -49822,7 +50237,7 @@ async function canonicalPath(path, allowMissing) {
       suffix.unshift(basename(candidate));
       candidate = parent;
       try {
-        return join10(await realpath2(candidate), ...suffix);
+        return join11(await realpath2(candidate), ...suffix);
       } catch (parentError) {
         if (!isMissingError(parentError)) {
           throw fsError(path, parentError);
@@ -49831,8 +50246,8 @@ async function canonicalPath(path, allowMissing) {
     }
   }
 }
-function isFencedPath(canonicalPath, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join10(resolve2(homeDirectory), ".local", "share")) {
-  const cortexkitRoot = join10(resolve2(dataDirectory), "cortexkit");
+function isFencedPath(canonicalPath, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join11(resolve2(homeDirectory), ".local", "share")) {
+  const cortexkitRoot = join11(resolve2(dataDirectory), "cortexkit");
   const relativeToCortexkit = relative(cortexkitRoot, canonicalPath);
   const insideCortexkit = relativeToCortexkit !== "" && relativeToCortexkit !== ".." && !relativeToCortexkit.startsWith(`..${sep}`) && !isAbsolute(relativeToCortexkit);
   const parts = insideCortexkit ? relativeToCortexkit.split(sep) : [];
@@ -50511,7 +50926,7 @@ function formatCtxReduceReply(stampedCount, selfStampCount = 0) {
   return parts.join(" ");
 }
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // src/features/magic-context/range-parser.ts
 function parseRangeString(input) {
@@ -50574,11 +50989,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash16("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash17("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash16("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash17("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool({
     description: CTX_REDUCE_DESCRIPTION,
@@ -51420,7 +51835,7 @@ async function registerContext(context) {
   }
   const folds = new FoldOwner(context.storage);
   const nativeFoldMemory = !compactionOff && process.env.MC_OC2_INVISIBLE_FOLD === "1" ? nativeFoldCache(() => storage.require()) : undefined;
-  const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader()) : undefined;
+  const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader(), context.storage) : undefined;
   setOutputReserveConfig(config.output_reserve);
   const queriedModels = new Set;
   const rawLimits = new Map;
@@ -51472,6 +51887,7 @@ async function registerContext(context) {
     memorySyncRequestedSessions: rustMemorySyncRequestedSessions
   }) : undefined;
   const hiddenChildHook = new HiddenChildHook;
+  await context.session.hook("http.request", (draft) => hiddenChildHook.cacheRequest(draft));
   const tools = db && isDatabasePersisted(db) ? await registerTools(context, db, config, moduleToolBackends?.backends, (id) => hiddenChildHook.owns(id)) : undefined;
   const usage = new Map;
   const generateReplay = new V2GenerateReplay;
@@ -51848,83 +52264,114 @@ async function registerContext(context) {
   }) : undefined;
   const usageController = new AbortController;
   const usageDone = (async () => {
-    try {
-      for await (const value of context.event.subscribe({ signal: usageController.signal })) {
-        if (usageController.signal.aborted)
-          break;
-        const event = value;
-        if (!event.data?.sessionID)
-          continue;
-        const sessionID = event.data.sessionID;
-        if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
-          nativeFoldReplay?.onEvent(event);
-          restoredRows.forget(sessionID);
-        }
-        if (event.type === "session.error" || event.type === "session.execution.failed") {
-          const error = hiddenTerminalError(event);
-          if (error !== undefined)
-            hiddenSessionErrors.set(sessionID, error);
-          if (error !== undefined && db && !compactionOff) {
+    let retry = 0;
+    while (!usageController.signal.aborted) {
+      const subscribedAt = Date.now();
+      try {
+        for await (const value of context.event.subscribe({
+          signal: usageController.signal
+        })) {
+          if (usageController.signal.aborted)
+            break;
+          const event = value;
+          try {
+            if (event.type === "provider.updated" || event.type === "model.updated") {
+              queriedModels.clear();
+              continue;
+            }
+            if (!event.data?.sessionID)
+              continue;
+            const sessionID = event.data.sessionID;
+            if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
+              nativeFoldReplay?.onEvent(event);
+              restoredRows.forget(sessionID);
+            }
+            if (event.type === "session.error" || event.type === "session.execution.failed") {
+              const error = hiddenTerminalError(event);
+              if (error !== undefined)
+                hiddenSessionErrors.set(sessionID, error);
+              if (error !== undefined && db && !compactionOff) {
+                const model = liveModels.get(sessionID);
+                try {
+                  armLatestThinkingRecoveryFromError({
+                    db,
+                    sessionId: sessionID,
+                    error,
+                    providerID: model?.providerID,
+                    modelID: model?.modelID
+                  });
+                } catch (armError) {
+                  log2("[magic-context] v2 latest-thinking recovery arm failed", armError);
+                }
+              }
+              continue;
+            }
+            if (event.type === "session.deleted") {
+              clearLkgMeasuredRequest(sessionID);
+              deletedSessions.add(sessionID);
+              transform?.clearSessionLogState(sessionID);
+              if (db) {
+                markSessionCleanupPending(db, sessionID);
+                clearSession(db, sessionID);
+              }
+              rawProviders.get(sessionID)?.();
+              rawProviders.delete(sessionID);
+              usage.delete(sessionID);
+              hiddenSessionErrors.delete(sessionID);
+              storageNoticeBySession.delete(sessionID);
+              liveModels.delete(sessionID);
+              variants.delete(sessionID);
+              agents.delete(sessionID);
+              channel1.delete(sessionID);
+              commitSeenLastPass.delete(sessionID);
+              clearEmbedSessionState(sessionID);
+              historyRefreshSessions.delete(sessionID);
+              clearPendingMaterialization(pendingMaterializationSessions, sessionID);
+              lastHeuristicsTurnId.delete(sessionID);
+              restoredRows.forget(sessionID);
+              if (nativeFoldReplay)
+                await nativeFoldReplay.forget(sessionID);
+              else
+                await forgetNativeFoldProvenance(context.storage, sessionID);
+              generateReplay.forget(sessionID);
+              systemPromptRefreshSessions.delete(sessionID);
+              systemPrompt?.clearSession(sessionID);
+              tagger.cleanup(sessionID);
+              continue;
+            }
+            if (event.type !== "session.execution.succeeded")
+              continue;
             const model = liveModels.get(sessionID);
-            try {
-              armLatestThinkingRecoveryFromError({
-                db,
-                sessionId: sessionID,
-                error,
-                providerID: model?.providerID,
-                modelID: model?.modelID
+            if (model) {
+              await recordUsage({
+                sessionID,
+                model: { providerID: model.providerID, id: model.modelID }
               });
-            } catch (armError) {
-              log2("[magic-context] v2 latest-thinking recovery arm failed", armError);
+              if (!compactionOff && typeof await nativeFoldReplay?.baseline(sessionID) === "string")
+                hostFolds?.idle(sessionID);
             }
+          } catch (error) {
+            log2(`[magic-context] v2 event handler failed (type=${event.type ?? "unknown"}, session=${event.data?.sessionID ?? "none"})`, error);
           }
-          continue;
-        }
-        if (event.type === "session.deleted") {
-          clearLkgMeasuredRequest(sessionID);
-          deletedSessions.add(sessionID);
-          transform?.clearSessionLogState(sessionID);
-          if (db) {
-            markSessionCleanupPending(db, sessionID);
-            clearSession(db, sessionID);
-          }
-          rawProviders.get(sessionID)?.();
-          rawProviders.delete(sessionID);
-          usage.delete(sessionID);
-          hiddenSessionErrors.delete(sessionID);
-          storageNoticeBySession.delete(sessionID);
-          liveModels.delete(sessionID);
-          variants.delete(sessionID);
-          agents.delete(sessionID);
-          channel1.delete(sessionID);
-          commitSeenLastPass.delete(sessionID);
-          clearEmbedSessionState(sessionID);
-          historyRefreshSessions.delete(sessionID);
-          clearPendingMaterialization(pendingMaterializationSessions, sessionID);
-          lastHeuristicsTurnId.delete(sessionID);
-          restoredRows.forget(sessionID);
-          await nativeFoldReplay?.forget(sessionID);
-          generateReplay.forget(sessionID);
-          systemPromptRefreshSessions.delete(sessionID);
-          systemPrompt?.clearSession(sessionID);
-          tagger.cleanup(sessionID);
-          continue;
-        }
-        if (event.type !== "session.execution.succeeded")
-          continue;
-        const model = liveModels.get(sessionID);
-        if (model) {
-          await recordUsage({
-            sessionID,
-            model: { providerID: model.providerID, id: model.modelID }
-          });
-          if (!compactionOff && typeof await nativeFoldReplay?.baseline(sessionID) === "string")
-            hostFolds?.idle(sessionID);
         }
+      } catch (error) {
+        if (!usageController.signal.aborted)
+          log2("[magic-context] v2 usage subscription failed", error);
+      }
+      if (usageController.signal.aborted)
+        break;
+      if (Date.now() - subscribedAt >= 30000)
+        retry = 0;
+      const ceiling = Math.min(30000, 250 * 2 ** retry);
+      retry = Math.min(retry + 1, 7);
+      try {
+        await delay(ceiling * (0.5 + Math.random() * 0.5), undefined, {
+          signal: usageController.signal
+        });
+      } catch (error) {
+        if (!usageController.signal.aborted)
+          throw error;
       }
-    } catch (error) {
-      if (!usageController.signal.aborted)
-        log2("[magic-context] v2 usage subscription failed", error);
     }
   })();
   const materialize = (draft) => {
@@ -52197,6 +52644,7 @@ async function registerContext(context) {
         compactionOff,
         storeGeneration: "v2",
         normalizeRestoredAssistantText: stripCopiedTagNotation,
+        refreshSourceContents: (sessionID) => nativeFoldReplay?.needsHeadRebuild(sessionID) ?? false,
         hostCleanupCompactionMarkers: () => ({
           verified: true,
           removedLineages: 0,
@@ -52285,12 +52733,13 @@ async function registerContext(context) {
           historyRefreshSessions.add(draft.sessionID);
           requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "boundary_repair");
         }
-        const incoming = cut && draft.messages.find((message) => message.id === cut.id);
+        const localCut = cut && isLocalCheckpoint(cut) ? cut : undefined;
+        const incoming = localCut && draft.messages.find((message) => message.id === localCut.id);
         postFold = cut !== undefined;
-        if (cut && !incoming)
+        if (localCut && !incoming)
           throw new Error("The host checkpoint disappeared from the context draft");
         let nativeRestored;
-        if (cut && nativeFoldReplay && isLocalCheckpoint(cut)) {
+        if (cut && nativeFoldReplay && await nativeFoldReplay.admits(draft.sessionID, cut, reader)) {
           try {
             nativeRestored = await nativeFoldReplay.restore(draft.sessionID, cut, `${draft.model.providerID}/${draft.model.id}`, { bounded: !rustModeModuleClient });
           } catch (error) {
@@ -52299,7 +52748,11 @@ async function registerContext(context) {
             nativeRestored = await nativeFoldReplay.restoreRead(draft.sessionID, cut, draft.model);
           }
         }
-        if (nativeRestored && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
+        if (cut && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
+          if (db && !rustModeModuleClient && nativeFoldReplay.needsHeadRebuild(draft.sessionID))
+            clearCachedM0(db, draft.sessionID);
+          if (nativeFoldReplay.needsHeadRebuild(draft.sessionID))
+            restoredRows.forget(draft.sessionID);
           historyRefreshSessions.add(draft.sessionID);
           requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_history_change");
         }
@@ -52310,25 +52763,27 @@ async function registerContext(context) {
             return !id || !present.has(id);
           });
           draft.messages.splice(0, draft.messages.length, ...hidden, ...draft.messages.filter((message) => message !== incoming));
-        } else if (cut && incoming) {
-          const identity = await folds.observe({
-            sessionID: draft.sessionID,
-            cutSeq: cut.seq,
-            summary: cut.data.summary ?? "",
-            rendered: incoming,
-            onHard: (reason) => {
-              sessionLog2(draft.sessionID, `HARD reason=${reason}`);
-              materialize(draft);
-              requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
-            }
-          });
-          checkpoint = structuredClone(identity.rendered ?? incoming);
-          submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
+        } else if (localCut && cut && incoming) {
+          if (!nativeFoldReplay) {
+            const identity = await folds.observe({
+              sessionID: draft.sessionID,
+              cutSeq: cut.seq,
+              summary: cut.data.summary ?? "",
+              rendered: incoming,
+              onHard: (reason) => {
+                sessionLog2(draft.sessionID, `HARD reason=${reason}`);
+                materialize(draft);
+                requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
+              }
+            });
+            checkpoint = structuredClone(identity.rendered ?? incoming);
+            submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
+          }
           const moduleBoundaryID = rustModeModuleClient ? getPersistedCompactionMarkerState(db, draft.sessionID)?.boundaryMessageId ?? null : null;
           const moduleBoundarySeq = moduleBoundaryID ? reader.sequenceForId(draft.sessionID, moduleBoundaryID) : undefined;
           const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
           const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
-          const boundary = (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
+          const boundary = (nativeFoldReplay?.sourceChanged(draft.sessionID) && !rustModeModuleClient ? (reader.earliestSequence(draft.sessionID) ?? 0) - 1 : undefined) ?? (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
           if (moduleBoundarySeq !== undefined)
             sessionLog2(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
           const present = new Set(draft.messages.map((message) => message.id));
@@ -52579,13 +53034,13 @@ ${baseline}
   }, 0));
   return {
     async dispose() {
+      usageController.abort();
       await hiddenCompletionExecutor?.dispose();
+      await usageDone;
       rpcStopped = true;
       rpcServer.stop();
       transform?.disposeRust();
       tools?.dispose();
-      usageController.abort();
-      await usageDone;
       deletedSessions.clear();
       await dreamTrigger?.dispose();
       await maintenanceTimer?.dispose();