@retaw106/mmc-oc 2.4.0 → 2.5.0

package/dist/{context-c72brxe5.js → context-xx09sh1g.js}

@@ -71,7 +71,6 @@ import {
   searchMemoriesFTSUnion,
   clearMemoryVerifications,
   queueMemoryMutation,
-  scheduleAfterBootQuiet,
   BoundedSessionMap,
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -81,6 +80,12 @@ import {
   dirtyLkgRecoveryRevision,
   ownsLkgDirtyFence,
   invalidateCleanLkgRecoveryFence,
+  cleanSearchText,
+  keywordRelevance,
+  matchedSearchSnippet,
+  gaDatabasePath,
+  RAW_MESSAGE_TYPES,
+  V2StoreReaderPool,
   getLastIndexedOrdinal,
   getIndexedMessageIdAtOrdinal,
   getIndexedMessageCorpusSize,
@@ -88,6 +93,8 @@ import {
   isMessageIndexReconciledThrough,
   clearIndexedMessages,
   indexMessagesAfterOrdinal,
+  sweepOrphanedOpenCodeMessageIndexesCooperatively,
+  scheduleAfterBootQuiet,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -95,6 +102,7 @@ import {
   getMaxM0MutationId,
   ensureSessionMetaRow,
   clearCachedM0M1,
+  clearCachedM0,
   getCompartments,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
@@ -187,9 +195,6 @@ import {
   getUnpublishedAutoSearchNoHint,
   forgetUnpublishedAutoSearchNoHint,
   registerAutoSearchWork,
-  gaDatabasePath,
-  RAW_MESSAGE_TYPES,
-  V2StoreReaderPool,
   getOrCreateSessionMeta,
   updateSessionMeta,
   advanceToolReclaimWatermark,
@@ -292,6 +297,7 @@ import {
   prepareCachedM0M1Replay,
   hasCompleteCachedM0M1,
   injectM0M1,
+  omitIncompleteFileTokenTotals,
   RECOVERY_NO_HEAD_LIMIT,
   deriveProtectedTailTokenTarget,
   selectPerRunCap,
@@ -301,7 +307,7 @@ import {
   recordHighPressureNoEligibleHead,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-kahkxcqw.js";
+} from "./index-0d40b4q8.js";
 import {
   getHarness,
   getDataDir,
@@ -429,12 +435,16 @@ import {
   pickNearestPriorOwner,
   expandToolPart,
   markHostUnservedRow,
+  isHostRenderedSystemMessage,
+  markCoveredInstructionRow,
+  isCoveredInstructionRow,
+  takeCoveredInstructionRows,
+  cloneKeepingCoveredInstructionMarks,
   estimateTrueRawMessageTokens,
   stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
-  buildFileSourceContent,
   toolPartHasUserAnswer,
   recordToolParameters,
   createDroppedInputGuard,
@@ -477,12 +487,13 @@ import {
   hasRawSessionMessageById2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-48e9znrc.js";
+} from "./index-1vxffj5j.js";
 import {
   normalizeModelEntry2,
   resolveHistorianModel2
 } from "./index-azbmnekv.js";
 import {
+  Database,
   getSqliteMemoryStats,
   withSqliteBackgroundWriter,
   withSqliteTransformPass,
@@ -492,7 +503,7 @@ import {
   withAsyncPrivilegedWriter,
   indexCoordinationInput,
   withIndexChunk
-} from "./index-dwh99z66.js";
+} from "./index-pte3cfs9.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -509,7 +520,7 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-ykq24x1n.js";
+} from "./index-bpjjcdy9.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -522,11 +533,14 @@ import {
   getErrorMessage,
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./index-r7s7d350.js";
+} from "./index-k25thxq7.js";
 import {
   logSlowWriteTransaction
 } from "./index-yjv8dpht.js";
 
+// src/v2/hooks/context.ts
+import { setTimeout as delay } from "node:timers/promises";
+
 // src/config/index.ts
 import { existsSync as existsSync4 } from "node:fs";
 
@@ -5041,6 +5055,8 @@ var RECONCILIATION_BATCH_SIZE = 100;
 
 class MagicContextMessageIndexHeapHolder {
   reconciledSessions = new Set;
+  reconciledSnapshots = new Map;
+  stalledSessions = new Set;
   reconciliationScheduledSessions = new Set;
   clearAndReindexScheduledSessions = new Map;
   sessionLocks = new Map;
@@ -5123,23 +5139,32 @@ function detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMess
     return null;
   return `indexed id '${indexedId}' at ordinal ${cursor} but projection has '${projectedId}'`;
 }
+function logReconciliationStall(sessionId, reason) {
+  if (heapHolder.stalledSessions.has(sessionId))
+    return;
+  heapHolder.stalledSessions.add(sessionId);
+  sessionLog(sessionId, `message FTS reconciliation stalled: ${reason}; will retry`);
+}
 async function reconcileSessionIndex(db, sessionId, readMessages) {
   if (!await sourceReady(readMessages, sessionId))
     return false;
   await runWithSessionLock(sessionId, async () => {
-    if (heapHolder.reconciledSessions.has(sessionId))
+    if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId))
       return;
     let fallbackSnapshot = null;
     try {
       const fullReader = typeof readMessages === "function" ? readMessages : null;
-      const finalWatermark = readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
+      const revision = readMessages.getRevision?.(sessionId);
+      const previous = heapHolder.reconciledSnapshots.get(sessionId);
+      const finalWatermark = previous && revision === previous.revision ? previous.count : revision !== undefined && readMessages.getCountAfterRevision ? previous && revision > previous.revision ? previous.count + readMessages.getCountAfterRevision(sessionId, previous.revision, revision) : readMessages.getCountAfterRevision(sessionId, -1, revision) : readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
       let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
-      let after;
-      const misalignment = detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMessages, fallbackSnapshot);
+      let after = cursor === previous?.count ? previous.after : undefined;
+      const misalignment = revision !== undefined && previous && revision >= previous.revision ? null : detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMessages, fallbackSnapshot);
       if (misalignment !== null) {
         sessionLog(sessionId, `message FTS index misaligned (${misalignment}); clearing for full re-index`);
         withSqliteBackgroundWriter(() => clearIndexedMessages(db, sessionId));
         cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+        after = undefined;
       }
       while (cursor < finalWatermark) {
         const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
@@ -5159,6 +5184,22 @@ async function reconcileSessionIndex(db, sessionId, readMessages) {
       }
       if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
         heapHolder.reconciledSessions.add(sessionId);
+        heapHolder.stalledSessions.delete(sessionId);
+        if (revision !== undefined) {
+          if (!after && finalWatermark > 0 && readMessages.readPage) {
+            const last = readMessages.readPage(sessionId, finalWatermark - 1, 1, finalWatermark).at(-1);
+            if (last?.ordinal === finalWatermark && typeof last.createdAt === "number")
+              after = { timeCreated: last.createdAt, id: last.id };
+          }
+          heapHolder.reconciledSnapshots.set(sessionId, {
+            revision,
+            count: finalWatermark,
+            after
+          });
+        }
+      } else {
+        heapHolder.reconciledSessions.delete(sessionId);
+        logReconciliationStall(sessionId, `gap after ordinal ${cursor} (store count ${finalWatermark})`);
       }
     } finally {
       heapHolder.activeReconcilerBuffers.delete(sessionId);
@@ -5167,30 +5208,42 @@ async function reconcileSessionIndex(db, sessionId, readMessages) {
   return true;
 }
 function scheduleReconciliation(db, sessionId, readMessages) {
-  if (heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
+  if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
     return;
   }
   heapHolder.reconciliationScheduledSessions.add(sessionId);
   scheduleAfterBootQuiet(() => {
     defer(() => {
+      let appendedDuringReconciliation = false;
+      const previousSnapshot = heapHolder.reconciledSnapshots.get(sessionId);
       reconcileSessionIndex(db, sessionId, readMessages).then((ran) => {
-        if (ran)
+        if (ran) {
+          const snapshot = heapHolder.reconciledSnapshots.get(sessionId);
+          appendedDuringReconciliation = snapshot !== undefined && snapshot !== previousSnapshot && readMessages.getRevision !== undefined && readMessages.getRevision(sessionId) !== snapshot.revision;
           return;
+        }
         setTimeout(() => {
           heapHolder.reconciliationScheduledSessions.delete(sessionId);
           scheduleReconciliation(db, sessionId, readMessages);
         }, PREPARE_RETRY_MS).unref?.();
       }).catch((error) => {
-        logIndexingError(sessionId, "reconciliation", error);
+        heapHolder.reconciledSessions.delete(sessionId);
+        logReconciliationStall(sessionId, error instanceof Error ? error.message : String(error));
         if (isDatabaseLockedError(error))
           setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000).unref();
       }).finally(() => {
         heapHolder.reconciliationScheduledSessions.delete(sessionId);
+        if (appendedDuringReconciliation)
+          scheduleReconciliation(db, sessionId, readMessages);
       });
     });
   });
 }
 function scheduleReconciliationCatchup(db, sessionId, readMessages) {
+  if (readMessages.getRevision) {
+    scheduleReconciliation(db, sessionId, readMessages);
+    return;
+  }
   if (typeof readMessages.getCount !== "function") {
     scheduleReconciliation(db, sessionId, readMessages);
     return;
@@ -5208,6 +5261,7 @@ function scheduleReconciliationCatchup(db, sessionId, readMessages) {
 }
 function scheduleClearAndReindex(db, sessionId, readMessages) {
   heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciledSnapshots.delete(sessionId);
   heapHolder.reconciliationScheduledSessions.delete(sessionId);
   clearCompletedIncrementalKeys(sessionId);
   const existing = heapHolder.clearAndReindexScheduledSessions.get(sessionId);
@@ -5225,6 +5279,7 @@ function scheduleClearAndReindex(db, sessionId, readMessages) {
           return;
         heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
         heapHolder.reconciledSessions.delete(sessionId);
+        heapHolder.reconciledSnapshots.delete(sessionId);
         clearCompletedIncrementalKeys(sessionId);
         clearIndexedMessages(db, sessionId);
         cleared = true;
@@ -7200,7 +7255,7 @@ function searchMessagesInSnapshot(args, sessionFirst) {
       const filtered = rows.slice(0, limit);
       return filtered.map((row, rank) => ({
         source: "message",
-        content: previewText(row.content),
+        content: matchedSearchSnippet(row.content, args.query) || previewText(row.content),
         score: linearDecayScore(rank, filtered.length),
         messageOrdinal: row.messageOrdinal,
         messageId: row.messageId,
@@ -7275,7 +7330,7 @@ function searchMessagesInSnapshot(args, sessionFirst) {
     const ranked = [...fused.values()].sort((a, b) => b.score !== a.score ? b.score - a.score : a.row.messageOrdinal - b.row.messageOrdinal).slice(0, resultLimit);
     return ranked.map((entry, rank) => ({
       source: "message",
-      content: previewText(entry.row.content),
+      content: matchedSearchSnippet(entry.row.content, args.query) || previewText(entry.row.content),
       score: linearDecayScore(rank, ranked.length),
       messageOrdinal: entry.row.messageOrdinal,
       messageId: entry.row.messageId,
@@ -7592,7 +7647,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     if (options.diagnostics) {
       options.diagnostics.suppressedLiveMessageMatches = outcome.suppressedLiveMessageMatches;
     }
-    messageResults = outcome.results;
+    messageResults = outcome.results.filter((result) => result.messageId !== options.excludeMessageId);
   }
   const workspace = resolveSearchWorkspaceContext(db, projectPath);
   const [memoryOutcome, primerResults, noteResults] = await Promise.all([
@@ -7647,6 +7702,12 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       }).immediate();
     }
   }
+  if (options.autoHint) {
+    return results.map((result) => ({
+      ...result,
+      relevanceScore: cleanSearchText(result.content).length === 0 ? 0 : keywordRelevance(trimmedQuery, result.content)
+    }));
+  }
   return results;
 }
 var SEARCH_NOTE_EXPAND_HINT = "Use mmc_expand(start=N-10, end=N) around any note @msg anchor above to read the surrounding conversation context.";
@@ -8266,22 +8327,22 @@ function truncate(text, limit) {
     return normalized;
   return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
 }
-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 "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 "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);
     }
   }
@@ -8292,7 +8353,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}`);
@@ -8315,6 +8376,10 @@ ${trimmedBody}…
   }
   return wrapped;
 }
+function selectAutoSearchResults(results, threshold) {
+  const relevance = (result) => result.relevanceScore ?? result.score;
+  return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
+}
 
 // src/hooks/magic-context/transform-message-helpers.ts
 function isMeaningfulUserMessage(msg) {
@@ -8591,6 +8656,9 @@ async function runAutoSearchHint(args) {
           return null;
         const searchOptions = {
           limit: 10,
+          autoHint: true,
+          maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
+          excludeMessageId: userMsgId,
           memoryEnabled: options.memoryEnabled,
           visibleMemoryIds: options.visibleMemoryIds ?? null,
           sources: ["memory", "message"]
@@ -8615,11 +8683,15 @@ async function runAutoSearchHint(args) {
     if (results.length === 0) {
       return writeNoHintAndReconcile("empty");
     }
-    if (results[0].score < options.scoreThreshold) {
-      sessionLog(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${options.scoreThreshold}`);
+    results = selectAutoSearchResults(results, options.scoreThreshold);
+    if (results.length === 0) {
+      sessionLog(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");
     }
@@ -8683,6 +8755,30 @@ function getSessionErrorInfo(properties) {
   };
 }
 
+// src/hooks/magic-context/diagnostic-log-state.ts
+var states = new BoundedSessionMap(1000);
+var scope = (sessionId) => `${getMagicContextStorageDir()}\x00${getHarness()}\x00${sessionId}`;
+function diagnosticStateChanged(sessionId, category, state) {
+  const key = scope(sessionId);
+  const previous = states.get(key) ?? new Map;
+  if (previous.get(category) === state)
+    return false;
+  previous.set(category, state);
+  states.set(key, previous);
+  return true;
+}
+function clearDiagnosticLogState(sessionId) {
+  states.delete(scope(sessionId));
+}
+
+// src/hooks/magic-context/nudge-evaluation-log.ts
+function logNudgeEvaluation(sessionId, phase, line) {
+  const category = `${phase}:${line.split(":", 1)[0]}`;
+  const state = line.split(" ").filter((field) => /^(ctx_reduce|band|dampening|verdict|reason|lease)=/.test(field)).join(" ");
+  if (diagnosticStateChanged(sessionId, category, state))
+    sessionLog(sessionId, line);
+}
+
 // src/hooks/magic-context/stripped-command.ts
 function matchStrippedMagicContextCommand(parts) {
   if (parts.length !== 1)
@@ -8871,7 +8967,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
     evaluable: state.evaluable,
     generationInvalidated: state.generationInvalidated
   });
-  sessionLog(sessionId, formatChannel1Evaluation(decision));
+  logNudgeEvaluation(sessionId, "tool-completion", formatChannel1Evaluation(decision));
   setLastNudgeUndropped(args.db, sessionId, decision.nextLastNudge);
   const nextNudgeState = {
     ...nudgeState,
@@ -10358,6 +10454,35 @@ function systemPromptDates(prompt, sticky) {
   return { live: values.length ? JSON.stringify(values) : undefined, stable };
 }
 
+// src/hooks/magic-context/system-prompt-sticky-date.ts
+var STICKY_DATE_KEY = "systemPromptStickyDate";
+function readPersistedSystemPromptStickyDate(db, sessionId) {
+  try {
+    const saved = readReplayEnvelope(db, sessionId, "read")[STICKY_DATE_KEY];
+    return typeof saved === "string" && saved.length > 0 ? saved : undefined;
+  } catch (error) {
+    sessionLog(sessionId, "system prompt sticky date record unreadable:", error);
+    return;
+  }
+}
+function persistSystemPromptStickyDate(db, sessionId, stickyDate) {
+  try {
+    const written = updateReplayDocument(db, sessionId, (doc) => {
+      if (doc[STICKY_DATE_KEY] === stickyDate)
+        return false;
+      doc.version = 2;
+      doc[STICKY_DATE_KEY] = stickyDate;
+      return true;
+    });
+    if (!written)
+      sessionLog(sessionId, "system prompt sticky date record not written");
+    return written;
+  } catch (error) {
+    sessionLog(sessionId, "system prompt sticky date record write failed:", error);
+    return false;
+  }
+}
+
 // src/hooks/magic-context/system-date-refresh.ts
 var channels = new WeakMap;
 var outputUpdates = new WeakMap;
@@ -10428,6 +10553,7 @@ function beginSystemDateRequest(history, sessionId, stage, turnId, identity) {
       systemDone: false,
       messagesSeen: false,
       permitted: undefined,
+      signedThinkingKept: undefined,
       ambiguous: identity === undefined && (turnId === undefined || sameTurn)
     };
     const blocked = [...requests.values()].filter((candidate) => !candidate.explicit && candidate.ambiguous && !(candidate.systemSeen && candidate.messagesSeen) && candidate.turnId === turnId).length;
@@ -10450,6 +10576,10 @@ function systemDateRefreshPermission(history, request) {
   const current = state(history, request);
   return current?.ambiguous ? undefined : current?.permitted;
 }
+function systemDateSignedThinkingKept(history, request) {
+  const current = state(history, request);
+  return current?.ambiguous ? undefined : current?.signedThinkingKept;
+}
 function waitForSystemDateRefresh(history, request, apply) {
   const current = state(history, request);
   if (!current)
@@ -10464,7 +10594,7 @@ function retire(history, current) {
   if (unpairable) {
     const apply = current.waiting;
     current.waiting = undefined;
-    apply?.(false);
+    apply?.(false, undefined);
   }
   const channel = channels.get(history);
   const requests = channel?.get(current.sessionId);
@@ -10472,14 +10602,15 @@ function retire(history, current) {
   if (requests?.size === 0)
     channel?.delete(current.sessionId);
 }
-function finishSystemDateRefresh(history, request, permitted) {
+function finishSystemDateRefresh(history, request, permitted, signedThinkingKept) {
   const current = state(history, request);
   if (!current)
     return;
   current.permitted = current.ambiguous ? false : permitted;
+  current.signedThinkingKept = current.ambiguous ? undefined : signedThinkingKept;
   const apply = current.waiting;
   current.waiting = undefined;
-  apply?.(current.permitted);
+  apply?.(current.permitted, current.signedThinkingKept);
   retire(history, current);
 }
 function finishSystemDateHook(history, request) {
@@ -10515,6 +10646,15 @@ function createSystemPromptHashHandler(deps) {
   });
   const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
+  const recordedStickyDateBySession = new Map;
+  const recordedStickyDate = (sessionId) => {
+    let recorded = recordedStickyDateBySession.get(sessionId);
+    if (recorded === undefined) {
+      recorded = readPersistedSystemPromptStickyDate(deps.db, sessionId) ?? null;
+      recordedStickyDateBySession.set(sessionId, recorded);
+    }
+    return recorded ?? undefined;
+  };
   const processSystemPrompt = async (input, output) => {
     const sessionId = input.sessionID;
     if (!sessionId)
@@ -10583,18 +10723,37 @@ function createSystemPromptHashHandler(deps) {
     const hasPersistedHash = previousHash !== "" && previousHash !== "0";
     if (!hasPersistedHash)
       stickyDateBySession.delete(sessionId);
-    const stickyDate = stickyDateBySession.get(sessionId);
+    let stickyDate = stickyDateBySession.get(sessionId);
+    if (stickyDate === undefined && hasPersistedHash) {
+      const recorded = recordedStickyDate(sessionId);
+      const live = systemPromptDates(liveSystemContent).live;
+      if (recorded !== undefined && live !== undefined && recorded !== live && systemPromptFingerprint(systemPromptDates(liveSystemContent, recorded).stable, promptSurface.preset) === previousHash) {
+        stickyDate = recorded;
+        stickyDateBySession.set(sessionId, recorded);
+      }
+    }
+    const setStickyDate = (value) => {
+      stickyDateBySession.set(sessionId, value);
+      if (value !== recordedStickyDate(sessionId)) {
+        if (persistSystemPromptStickyDate(deps.db, sessionId, value))
+          recordedStickyDateBySession.set(sessionId, value);
+      }
+    };
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
     const stableCandidateHash = systemPromptFingerprint(stableCandidate, promptSurface.preset);
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
+    const signedThinkingKept = systemDateSignedThinkingKept(deps.historyRefreshSessions, dateRequest);
+    const prefixBoundModel = isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID);
+    const thinkingAllowsDate = (kept) => prefixBoundModel ? kept === false : kept !== true;
+    const systemDateMayMove = (rewrite, kept) => (rewrite || idleCacheExpired) && thinkingAllowsDate(kept);
     let deferredDateRefresh = false;
-    if (currentDate && stickyDate && currentDate !== stickyDate && isCacheBusting && !idleCacheExpired && !contentOrPresetChanged && !requestMessagesFinal) {
+    if (currentDate && stickyDate && currentDate !== stickyDate && (isCacheBusting || idleCacheExpired && isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID)) && rewritePermission === undefined && !contentOrPresetChanged && !requestMessagesFinal) {
       const liveElements = [...output.system];
-      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted) => {
-        if (!permitted) {
+      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted, keptSignedThinking) => {
+        if (!systemDateMayMove(permitted, keptSignedThinking)) {
           deps.systemPromptRefreshSessions.add(sessionId);
           return;
         }
@@ -10607,7 +10766,7 @@ function createSystemPromptHashHandler(deps) {
             cachedM0SystemHash: hash,
             systemPromptTokens: estimateTokens(content)
           });
-          stickyDateBySession.set(sessionId, currentDate);
+          setStickyDate(currentDate);
           output.system.splice(0, output.system.length, ...liveElements);
           publishSystemDateOutput(output.system);
           deps.systemPromptRefreshSessions.delete(sessionId);
@@ -10618,12 +10777,12 @@ function createSystemPromptHashHandler(deps) {
         }
       });
     }
-    const dateMayAdvance = idleCacheExpired || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
+    const dateMayAdvance = thinkingAllowsDate(signedThinkingKept) && (contentOrPresetChanged || !deferredDateRefresh && systemDateMayMove(isCacheBusting && (dateRequest ? rewritePermission === true : rewritePermission !== false), signedThinkingKept));
     if (currentDate && !stickyDate) {
-      stickyDateBySession.set(sessionId, currentDate);
+      setStickyDate(currentDate);
     } else if (currentDate && stickyDate && currentDate !== stickyDate) {
       if (dateMayAdvance) {
-        stickyDateBySession.set(sessionId, currentDate);
+        setStickyDate(currentDate);
         sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
       } else {
         let offset = 0;
@@ -10678,7 +10837,7 @@ function createSystemPromptHashHandler(deps) {
         sessionLog(sessionId, "system prompt meta persist failed (fail-open):", error);
       }
     }
-    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true)) {
+    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged && thinkingAllowsDate(signedThinkingKept) || !currentDate || currentDate === stickyDate || !dateRequest && thinkingAllowsDate(signedThinkingKept) || rewritePermission === true && thinkingAllowsDate(signedThinkingKept))) {
       deps.systemPromptRefreshSessions.delete(sessionId);
     }
   };
@@ -10692,6 +10851,7 @@ function createSystemPromptHashHandler(deps) {
   return {
     handler,
     clearSession: (sessionId) => {
+      recordedStickyDateBySession.delete(sessionId);
       clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
@@ -11867,6 +12027,8 @@ var PASS_DEGRADATION_EFFECTS = {
   "stale-reduce-strip-exception": "changes-request",
   "image-strip-exception": "changes-request",
   "m0-m1-injection-degradation": "changes-request",
+  "host-instruction-retention-read-failure": "changes-request",
+  "host-instruction-retention-persistence-failure": "changes-request",
   "m0-m1-fallback-failure": "changes-request",
   "compaction-marker-drain-failure": "changes-request",
   "auto-search-timeout": "served",
@@ -12165,7 +12327,7 @@ async function runCompartmentPhaseImpl(args) {
     justAwaitedPublication = activeRun.published;
     published = published || activeRun.published;
     const historyReprepareShouldBust = activeRun.published && args.deferredHistoryRefreshSessions.has(args.sessionId);
-    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness);
+    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness, args.coveredHostInstructions);
     if (historyReprepareShouldBust) {
       rebuiltHistoryThisPass = true;
     }
@@ -12382,7 +12544,7 @@ function capturePendingDropEligibility(targets, protectedTagIds) {
         eligible.add(number);
     } else {
       const content = target.getContent?.();
-      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length)
+      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length && target.canSetContent?.(`[dropped §${number}§]`) !== false)
         eligible.add(number);
     }
   }
@@ -12440,27 +12602,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 hasSmallToolInput(target) {
   const bytes = target?.inputStringBytes?.() ?? null;
@@ -12542,6 +12720,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;
@@ -12551,159 +12730,188 @@ 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 neededTagNumbers = new Set(pendingOps.map((op) => op.tagId));
-      for (const op of syntheticPendingOps)
-        neededTagNumbers.add(op.tagId);
-      const tags = preloadedTags ?? getTagsByNumbers(db, sessionId, (() => {
-        const newest = getNewestToolTagNumbers(db, sessionId, RECENT_TOOL_SKELETON_WINDOW);
-        const numbers = [...neededTagNumbers];
-        for (const tagNumber of newest) {
-          if (!neededTagNumbers.has(tagNumber))
-            numbers.push(tagNumber);
-        }
-        return numbers;
-      })());
-      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(getNewestToolTagNumbers(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;
         }
-        let shouldPersistDrop = false;
-        const persistDrop = (mode) => {
-          let startedAt = 0;
-          try {
-            db.transaction(() => {
-              startedAt = performance.now();
-              markTagDropped(db, sessionId, pendingOp.tagId, mode);
+        const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+        onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
+        const tags = preloadedTags ?? getTagsByNumbers(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) : getNewestToolTagNumbers(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);
-          }
-        };
-        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) => {
+              markTagDropped(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);
+              if (target.canSetContent?.(replacement) === false) {
+                reject("content_unchanged");
+                continue;
+              }
+              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))) {
+        sessionLog(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))) {
-      sessionLog(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) {
@@ -12937,10 +13145,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)
+        sessionLog(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}` : "";
-  sessionLog(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)
+    sessionLog(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
@@ -13318,13 +13557,19 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         }));
         accAssignTag += performance.now() - _tAssignText;
         const persistedSource = sourceContents.get(tagId);
-        if (persistedSource !== undefined) {
-          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource) : persistedSource;
+        if (persistedSource !== undefined && !options.refreshSourceContents) {
+          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource, message.info.providerID) : 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) {
+              db.transaction(() => {
+                replaceSourceContent(db, sessionId, tagId, sourceContent);
+                db.prepare("UPDATE tags SET byte_size = ?, token_count = ? WHERE session_id = ? AND tag_number = ?").run(byteSize(sourceContent), estimateTextTagTokenCount(sourceContent), sessionId, tagId);
+              }).immediate();
+            } else
+              saveSourceContent(db, sessionId, tagId, sourceContent);
             accSaveSource += performance.now() - _tSaveText;
           }
         }
@@ -13343,6 +13588,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           dropReasoningParts: thinkingParts,
           mutationParts: [{ message, part: textPart }],
           textPrefix: skipPrefixInjection ? "" : prependTag(tagId, ""),
+          canSetContent: (content) => textPart.text !== content,
           setContent: (content, options) => {
             if (textPart.text === content)
               return false;
@@ -13400,26 +13646,20 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         const filePart = part;
         const messageParts = message.parts;
         const contentId = `${messageId}:file${partIndex}`;
-        const existingTagId = resolver.resolve(messageId, "file", contentId, fileOrdinal);
-        const _tAssignFile = performance.now();
-        const tagId = existingTagId ?? tagger.assignTag(sessionId, contentId, "file", byteSize(filePart.url), db, 0, null, 0, null, () => ({
-          tokenCount: estimateTextTagTokenCount(filePart.url),
-          inputTokenCount: null,
-          reasoningTokenCount: null
-        }));
-        accAssignTag += performance.now() - _tAssignFile;
-        if (existingTagId === undefined) {
-          const sourceContent = buildFileSourceContent(message.parts);
-          if (sourceContent) {
-            const _tSaveFile = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
-            accSaveSource += performance.now() - _tSaveFile;
-          }
-        }
+        const existingTagId = resolver.resolve(messageId, "file", contentId, fileOrdinal) ?? getTagNumberByMessageId(db, sessionId, contentId) ?? undefined;
+        fileOrdinal += 1;
+        if (existingTagId === undefined)
+          continue;
+        const tagId = existingTagId;
+        tagger.bindTag(sessionId, contentId, tagId);
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         targets.set(tagId, {
           message,
           mutationParts: [{ message, part: filePart }],
+          canSetContent: (content) => {
+            const current = messageParts[partIndex];
+            return !(typeof current === "object" && current !== null && ("text" in current) && current.text === content);
+          },
           setContent: (content) => {
             const prev = messageParts[partIndex];
             const prevText = typeof prev === "object" && prev !== null && "text" in prev ? prev.text : "";
@@ -13432,7 +13672,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             return true;
           }
         });
-        fileOrdinal += 1;
       }
     }
     if (message.info.role === "assistant" && !messageHasTextPart) {
@@ -13461,6 +13700,23 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
     normalizationTargets
   };
 }
+// src/features/magic-context/storage-host-instruction-retention.ts
+var NAMESPACE3 = "hostInstructionRetention";
+function isHostInstructionRetentionOn(db, sessionId) {
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE3];
+  return typeof lane === "object" && lane !== null && lane.on === true;
+}
+function markHostInstructionRetention(db, sessionId) {
+  return updateReplayDocument(db, sessionId, (doc) => {
+    const lane = doc[NAMESPACE3];
+    if (typeof lane === "object" && lane !== null && lane.on === true)
+      return false;
+    doc.version = 2;
+    doc[NAMESPACE3] = { on: true };
+    return true;
+  });
+}
+
 // src/hooks/magic-context/channel2-cycle.ts
 function rearmChannel2AfterCoverageAdvancingHardFold(input) {
   if (input.compactionOff || !input.foldExecuted || input.previousCoverage === null || input.currentCoverage === null || input.currentCoverage <= input.previousCoverage) {
@@ -14374,6 +14630,28 @@ function freezeReasoningOnBustingPass(args) {
   sessionLog(args.sessionId, `proactive thinking strip: busting pass froze reasoning of ${messageIds.length} assistant(s) [${messageIds.join(",")}]`);
   return { strip: { messageIds }, persistenceFailed: false };
 }
+function servesThinkingBlock(messages) {
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (const part of message.parts) {
+      if (!isRecord(part) || part.ignored === true)
+        continue;
+      if (part.type === "redacted_thinking")
+        return true;
+      if (part.type !== "reasoning" && part.type !== "thinking")
+        continue;
+      const anthropic = isRecord(part.metadata) ? part.metadata.anthropic : undefined;
+      if (!isRecord(anthropic))
+        continue;
+      if (anthropic.redactedData !== undefined)
+        return true;
+      if (typeof part.text === "string" && part.text !== "")
+        return true;
+    }
+  }
+  return false;
+}
 function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
   const tagNumber = getTagNumberByMessageId(db, sessionId, `${summaryMessageId}:p0`);
   if (tagNumber !== null)
@@ -14537,7 +14815,7 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
       clearedParts = stripClearedReasoning(targetedMessages.filter((message) => !restoredMessages.has(message)));
     }
   }
-  const bindingRecoveryParts = options?.skipMergedReasoningStrip ? 0 : stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
+  const bindingRecoveryParts = stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
   const mergedReasoningParts = bindingRecoveryParts + (options?.skipMergedReasoningStrip ? 0 : stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
     mutationExemptMessage: options?.reasoningMutationExemptMessage,
     frozenMessageIds: options?.mergedReasoningStrippedIds,
@@ -14614,7 +14892,7 @@ async function runPostTransformPhase(args) {
   let deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   let materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
-  const frozenThinking = new Set(args.activeThinkingTurn ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
+  const frozenThinking = new Set(getMergedReasoningStrippedIds(args.db, args.sessionId));
   const bindingThinking = new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
   const retainedThinking = args.activeThinkingTurn ? retainedActiveThinkingParts({
     messages: args.messages,
@@ -14640,6 +14918,7 @@ async function runPostTransformPhase(args) {
   let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
   let rewritingSignedPrefix = false;
   let thinkingReleasedForFit = false;
+  let thinkingOmissionPersistenceFailed = false;
   const releaseThinkingForRewrite = (forFit = false) => {
     const stripped = freezeReasoningOnBustingPass({
       db: args.db,
@@ -14647,8 +14926,12 @@ async function runPostTransformPhase(args) {
       messages: args.messages,
       alreadyFrozen: bindingThinking
     });
-    if (stripped.persistenceFailed)
+    if (stripped.persistenceFailed) {
+      thinkingOmissionPersistenceFailed = true;
       throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    }
+    for (const id of stripped.strip?.messageIds ?? [])
+      bindingThinking.add(id);
     retainedThinking.clear();
     protectedThinkingMessages.clear();
     activeThinkingTurn = false;
@@ -14658,6 +14941,9 @@ async function runPostTransformPhase(args) {
     rewritingSignedPrefix = true;
     thinkingReleasedForFit ||= forFit;
   };
+  if (args.compactionModeTransition && args.thinkingBindingRecoveryEnabledForModel) {
+    releaseThinkingForRewrite();
+  }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -14693,6 +14979,8 @@ async function runPostTransformPhase(args) {
   };
   if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
+    let committedFoldChangesHead = false;
+    let committedFoldThinkingIds = [];
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
       const foldResult = injectM0M1({
@@ -14719,6 +15007,24 @@ async function runPostTransformPhase(args) {
               m0Text: rendered.m0Bytes.toString(),
               m1Text: rendered.m1Bytes.toString()
             }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            committedFoldChangesHead = firstRenderBust ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString()
+            }) : foldChangesServedPrefix(servedPrefixBeforeFold, rendered);
+            if (args.thinkingBindingRecoveryEnabledForModel && (compactionOff && !activeThinkingPrefixHold && committedFoldChangesHead || activeThinkingPrefixHold && firstRenderBust && bustsPrefix)) {
+              const omission = freezeReasoningOnBustingPass({
+                db,
+                sessionId: args.sessionId,
+                messages: args.messages,
+                alreadyFrozen: bindingThinking
+              });
+              if (omission.persistenceFailed) {
+                thinkingOmissionPersistenceFailed = true;
+                throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+              }
+              committedFoldThinkingIds = omission.strip?.messageIds ?? [];
+            }
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -14735,7 +15041,13 @@ async function runPostTransformPhase(args) {
         }
       });
       preparedPrefix = foldResult;
-      if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+      if (foldResult.m0RematerializedThisPass) {
+        for (const id of committedFoldThinkingIds)
+          bindingThinking.add(id);
+      }
+      if (foldResult.m0RematerializedThisPass && activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+        releaseThinkingForRewrite();
+      } else if (compactionOff && foldResult.m0RematerializedThisPass && !activeThinkingPrefixHold && args.thinkingBindingRecoveryEnabledForModel && committedFoldChangesHead) {
         releaseThinkingForRewrite();
       }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
@@ -14764,6 +15076,8 @@ async function runPostTransformPhase(args) {
         sessionLog(args.sessionId, "channel2 fold-cycle reset failed (ignored):", error);
       }
     } catch (error) {
+      if (thinkingOmissionPersistenceFailed)
+        throw error;
       preparedPrefix = cachedPrefixBeforePreflight;
       prefixPreflightFailed = true;
       failPass("m0-m1-fold-preexecution-degradation", error);
@@ -14881,17 +15195,28 @@ async function runPostTransformPhase(args) {
       throw new EmergencyFailClosedError("Magic Context could not read its saved reasoning-removal state for this session", { cause: error });
     }
   }
+  const heuristicsLogChanged = diagnosticStateChanged(args.sessionId, "heuristics", JSON.stringify([
+    args.currentTurnId,
+    shouldRunHeuristics,
+    shouldRunHeuristics ? null : args.schedulerDeferReason
+  ]));
+  const pendingLogChanged = diagnosticStateChanged(args.sessionId, "pending-ops", JSON.stringify([
+    args.currentTurnId,
+    shouldApplyPendingOps,
+    shouldApplyPendingOps ? null : args.schedulerDeferReason,
+    shouldApplyPendingOps ? null : (getPendingOpsCount(args.db, args.sessionId) ?? 0) > 0
+  ]));
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
     const reason = isExplicitFlush ? `pending_materialization origin=${pendingOrigin}` : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `${reclaimRideLabel(rideSignals)} subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
-  } else if (args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  } else if (heuristicsLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog(args.sessionId, `heuristics WILL NOT RUN — reason=${args.schedulerDeferReason}`);
   }
   if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
     sessionLog(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
-  if (!shouldApplyPendingOps && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  if (!shouldApplyPendingOps && pendingLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog(args.sessionId, `pending ops WILL NOT APPLY — reason=${args.schedulerDeferReason} pendingOps=${formatPendingOpsDepth()} context=${args.contextUsage.percentage.toFixed(1)}%`);
   }
   if (hasPendingUserOps && !shouldApplyPendingOps) {
@@ -15278,6 +15603,30 @@ async function runPostTransformPhase(args) {
     }
   }
   const m0M1Enabled = m0M1EnabledForFold;
+  let retainCoveredInstructions = false;
+  if (m0M1Enabled && args.m0M1 && !compactionOff && args.hostInstructionRows) {
+    const covered = args.coveredHostInstructions ?? [];
+    if (covered.length > 0 || canEditWholePrefix) {
+      let retain = false;
+      try {
+        retain = isHostInstructionRetentionOn(args.db, args.sessionId);
+      } catch (error) {
+        failPass("host-instruction-retention-read-failure", error);
+      }
+      if (!retain && canEditWholePrefix) {
+        let written = false;
+        try {
+          written = markHostInstructionRetention(args.db, args.sessionId);
+        } catch (error) {
+          failPass("host-instruction-retention-persistence-failure", error);
+        }
+        if (!written)
+          failPass("host-instruction-retention-persistence-failure");
+        retain = true;
+      }
+      retainCoveredInstructions = retain;
+    }
+  }
   if (m0M1Enabled && args.m0M1) {
     if (freezeM0M1 && !preparedPrefix) {
       preparedPrefix = prepareCachedM0M1Replay(args.db, args.sessionId);
@@ -15305,6 +15654,17 @@ async function runPostTransformPhase(args) {
         compactionOff
       });
       deliveredPrefix = result;
+      if (retainCoveredInstructions) {
+        const retained = new Set(args.messages);
+        const covered = [...args.coveredHostInstructions ?? []];
+        for (const message of messagesBeforeInjection) {
+          if (!retained.has(message) && isHostRenderedSystemMessage(message)) {
+            markCoveredInstructionRow(message.info);
+            covered.push(message);
+          }
+        }
+        args.messages.splice(result.prependedMessageCount, 0, ...covered);
+      }
       if (result.prefixTrimStatus === "applied") {
         const retainedMessages = new Set(args.messages);
         const trimmedMessageIds = messagesBeforeInjection.filter((message) => !retainedMessages.has(message)).map((message) => message.info.id).filter((id) => typeof id === "string");
@@ -15575,7 +15935,7 @@ async function runPostTransformPhase(args) {
     }
   }
   const mergedReasoningStrippedIds = new Set(replaySnapshot?.mergedReasoningStrippedIds ?? []);
-  const thinkingBindingRecoveryMessageIds = new Set;
+  const thinkingBindingRecoveryMessageIds = new Set(bindingThinking);
   let thinkingBindingRecovery = null;
   let proactiveThinkingStrip = null;
   if (!compactionOff) {
@@ -16080,7 +16440,9 @@ function createTransform(deps) {
   const loadedSessions = new Set;
   const prefixHoldLogTurnIds = new Map;
   const thinkingFitRetries = new Set;
+  const compactionModeTransitionPending = new Set;
   const clearSessionLogState = (sessionId) => {
+    clearDiagnosticLogState(sessionId);
     prefixHoldLogTurnIds.delete(sessionId);
   };
   const unmanagedOverWindowSessions = new Set;
@@ -16101,7 +16463,8 @@ function createTransform(deps) {
     const startTime = performance.now();
     const historianRun = deps.resolveHistorianRun?.();
     const messages = output.messages;
-    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? structuredClone(messages) : null;
+    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? cloneKeepingCoveredInstructionMarks(messages) : null;
+    const coveredHostInstructions = takeCoveredInstructionRows(messages);
     const passOutcome = createPassOutcome();
     const tSessionId = performance.now();
     const sessionId = findSessionId(messages);
@@ -16199,6 +16562,7 @@ function createTransform(deps) {
       const hasTransitionEffects = transition.recordToWrite !== null || transition.notice !== null || transition.invalidatedM0Baseline || transition.clearedCompartmentInProgress || transition.historianCatchUpSignaled;
       if (hasTransitionEffects) {
         if (transition.invalidatedM0Baseline) {
+          compactionModeTransitionPending.add(sessionId);
           sessionMeta = {
             ...sessionMeta,
             cachedM0Bytes: null,
@@ -16627,8 +16991,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       recordedSessionProjectIdentity.set(sessionId, sessionIdentityForBinding);
     }
     const taggerFloor = compactionOff ? 0 : deriveTaggerLoadFloor(messages, sessionId, db);
-    if (!compactionOff && taggerFloor === 0 && messages.length > 0) {
-      sessionLog(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
+    const tagFloorMode = compactionOff || messages.length === 0 ? "inactive" : taggerFloor === 0 ? "fallback" : "scoped";
+    if (diagnosticStateChanged(sessionId, "tag-floor", tagFloorMode) && tagFloorMode !== "inactive") {
+      sessionLog(sessionId, taggerFloor === 0 ? `tag floor: 0 (full-scan fallback) — no scoped floor above the safety margin across ${messages.length} msgs` : `tag floor: ${taggerFloor} (scoped load)`);
     }
     const ownerRatio = sessionDecisionCalibration(db, sessionId).proseRatio;
     prewarmTagOwners(db, sessionId, ownerRatio);
@@ -16677,7 +17042,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const messagesBeforeInitialPrepare = isCacheBusting && deferredHistoryWasPendingAtPassStart ? [...messages] : null;
     if (fullFeatureMode && !compactionOff) {
       const tInj = performance.now();
-      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
+      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness, coveredHostInstructions);
       if (messagesBeforeInitialPrepare) {
         const skippedVisibleMessages = pendingCompartmentInjection?.skippedVisibleMessages ?? 0;
         trimmedMessagesAtCompactionBoundary = messagesBeforeInitialPrepare.slice(0, skippedVisibleMessages);
@@ -16707,6 +17072,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       logTransformTiming(sessionId, "injectTemporalMarkers", tTemporal);
     }
     let taggingSucceeded = false;
+    const refreshSourceContents = deps.storeGeneration === "v2" && fullFeatureMode && !compactionOff && !!(projectIdentity || sessionDirectory) && !unresolvedDirectoryHold && !recovery.prefix && sessionMeta.cachedM0Bytes == null && sessionMeta.cachedM1Bytes == null && deps.refreshSourceContents?.(sessionId) === true;
     let recoveryBatch = null;
     let recoveryNormalized = false;
     const normalizeRecoveryTail = recovery.prefix ? () => {
@@ -16742,7 +17108,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           scopedToolSweep,
           servedMessages: messages,
           protectedThinkingMessages: protectedThinkingMessagesForPass,
-          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText
+          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText,
+          refreshSourceContents
         });
         targets = result.targets;
         if (thinkingRecovery.restore)
@@ -16823,6 +17190,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const rawGetNotifParams = runNotificationParams;
     const tCompartmentPhase = performance.now();
     const compartmentPhase = await runCompartmentPhase({
+      coveredHostInstructions,
       hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
       compactionMarkerStrategy: deps.compactionMarkerStrategy,
       canRunCompartments,
@@ -16989,6 +17357,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       fullFeatureMode,
       compactionOff,
       canRunCompartments,
+      hostInstructionRows: deps.storeGeneration === "v2",
       awaitedCompartmentRun,
       phaseJustAwaitedPublication: compartmentPhase.justAwaitedPublication,
       compartmentInProgress,
@@ -16997,6 +17366,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       activeThinkingPrefixHold,
       directoryPrefixHold: unresolvedDirectoryHold,
       forceSignedRebuildForFit: thinkingFitRetries.has(sessionId) || !!recovery.rebuildReason,
+      compactionModeTransition: compactionModeTransitionPending.has(sessionId),
       readLastServedMessages: () => {
         const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
         try {
@@ -17026,6 +17396,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       emergencyCeilingTokens,
       pendingCompartmentInjection,
       prefixTrimSourceOrder,
+      coveredHostInstructions,
       hiddenMessagesAtCompactionSeam,
       trimmedMessagesAtCompactionBoundary,
       didMutateFromFlushedStatuses,
@@ -17220,7 +17591,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (!finalWireEstimate) {
       sessionLog(sessionId, `transform: final-wire telemetry estimate=unavailable trusted=false conversation=unknown tools=unknown system=unknown toolDefinitions=unknown tail=${finalWireTail}`);
     }
-    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold || postTransformResult.thinkingReleasedForFit === true);
+    const signedThinkingServed = isPrefixBoundThinkingModel(modelForBudget?.providerID, modelForBudget?.modelID) && servesThinkingBlock(messages);
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && !signedThinkingServed || postTransformResult.thinkingReleasedForFit === true, signedThinkingServed);
+    compactionModeTransitionPending.delete(sessionId);
     if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
       recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
     }
@@ -17322,6 +17695,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (uncachedMessageIds.length > 0) {
       try {
         storedByMessage = getActiveTagTokenTotalsByMessage(db, sessionId, uncachedMessageIds);
+        omitIncompleteFileTokenTotals(db, sessionId, messages.flatMap((message) => typeof message.info.id === "string" ? [{ id: message.info.id, parts: message.parts }] : []), storedByMessage);
       } catch {
         storedByMessage = new Map;
       }
@@ -17378,7 +17752,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           postReduceGraceBaselineU: channel1State.postReduceGraceBaselineU,
           postReduceGracePreLevel: channel1State.postReduceGracePreLevel
         });
-        sessionLog(sessionId, formatChannel1Evaluation(channel1Decision));
+        logNudgeEvaluation(sessionId, "transform", formatChannel1Evaluation(channel1Decision));
         const channel2Evaluation = evaluateChannel2(channelBaseline);
         const leaseBefore = getChannel2NudgeState(db, sessionId);
         if (channelBaseline.evaluable && !channelBaseline.generationInvalidated && !channelBaseline.reducedSinceRefresh) {
@@ -17389,7 +17763,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           }
         }
         const leaseAfter = getChannel2NudgeState(db, sessionId);
-        sessionLog(sessionId, formatChannel2Evaluation(channel2Evaluation, {
+        logNudgeEvaluation(sessionId, "transform", formatChannel2Evaluation(channel2Evaluation, {
           leaseBefore,
           leaseAfter,
           gateHoldReason: channelBaseline.reducedSinceRefresh ? "recent-reduce-refresh" : undefined
@@ -17428,7 +17802,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       sessionLog(sessionId, "memory maintenance launch probe failed (ignored):", error);
     }
   };
-  return Object.assign(transform, {
+  const timedTransform = (input, output) => withTransformTimingSummary(() => transform(input, output));
+  return Object.assign(timedTransform, {
     clearSessionLogState(sessionId) {
       clearSessionLogState(sessionId);
     }
@@ -18702,8 +19077,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-k760qy1n.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-njjf3b4s.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-mmpy5cb7.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-zpqs213d.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -18752,7 +19127,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await import("./wrapup-orchestrator-b2gswatj.js");
+    const { runManagedWrapup } = await import("./wrapup-orchestrator-jq589pgr.js");
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -18840,8 +19215,17 @@ function subagentToolRefusal(db, toolId, sessionId, isInternalChild = () => fals
 function hideSubagentTools(draft, db) {
   if (!getOrCreateSessionMeta(db, draft.sessionID).isSubagent)
     return;
+  removePrimaryOnlyTools(draft.tools);
+}
+function removePrimaryOnlyTools(tools) {
   for (const id of PRIMARY_ONLY_TOOLS)
-    delete draft.tools[id];
+    delete tools[id];
+}
+function storedSubagentMode(db, sessionId) {
+  const row = db.prepare("SELECT is_subagent FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!row || typeof row.is_subagent !== "number")
+    return;
+  return row.is_subagent === 1;
 }
 
 // src/shared/conflict-detector.ts
@@ -19099,7 +19483,58 @@ function readOmoDisabledHooks(directory) {
 
 // src/shared/rpc-server.ts
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { readdirSync, readFileSync as readFileSync6, unlinkSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync6, rmdirSync, unlinkSync } from "node:fs";
+
+// src/shared/rpc-discovery-cleanup.ts
+import { promises as fs } from "node:fs";
+import { join as join4 } from "node:path";
+async function reapDeadRpcDiscovery(storageDir) {
+  const root = join4(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 = join4(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 = join4(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;
@@ -19122,17 +19557,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);
   }
@@ -19150,6 +19588,10 @@ class MagicContextRpcServer {
       log("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 = Bun.serve({
@@ -19181,7 +19623,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,
@@ -19189,6 +19631,13 @@ class MagicContextRpcServer {
         token: this.token,
         instance_id: this.instanceId
       }));
+      try {
+        publish();
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+        publish();
+      }
       log(`[rpc] server listening on 127.0.0.1:${this.port}`);
     } catch (err) {
       log(`[rpc] failed to write port file: ${err}`);
@@ -19196,6 +19645,7 @@ class MagicContextRpcServer {
     return this.port;
   }
   stop() {
+    this.stopped = true;
     for (const ws of this.sockets) {
       try {
         if (ws.data.authTimer)
@@ -19212,6 +19662,9 @@ class MagicContextRpcServer {
     try {
       unlinkSync(this.portFilePath);
     } catch {}
+    try {
+      rmdirSync(this.portDir);
+    } catch {}
     this.unregisterOwnInstance?.();
     this.unregisterOwnInstance = null;
   }
@@ -19945,18 +20398,56 @@ function containsHostInstance(value) {
   return false;
 }
 function clonePreservingInstances(value) {
-  if (isHostInstance(value))
+  return cloneCounting(value, undefined);
+}
+function clonePreservingInstancesMeasured(value) {
+  const meter = { bytes: 0 };
+  const copy = cloneCounting(value, meter);
+  return { copy, bytes: meter.bytes };
+}
+function cloneCounting(value, meter) {
+  if (isHostInstance(value)) {
+    if (meter)
+      meter.bytes += instanceBytes(value, new WeakSet);
     return value;
-  if (Array.isArray(value))
-    return value.map(clonePreservingInstances);
+  }
+  if (Array.isArray(value)) {
+    if (meter)
+      meter.bytes += 16 + 8 * value.length;
+    return value.map((entry) => cloneCounting(entry, meter));
+  }
   if (value && typeof value === "object") {
     const copy = {};
-    for (const [key, entry] of Object.entries(value))
-      copy[key] = clonePreservingInstances(entry);
+    if (meter)
+      meter.bytes += 32;
+    for (const [key, entry] of Object.entries(value)) {
+      if (meter)
+        meter.bytes += 16;
+      copy[key] = cloneCounting(entry, meter);
+    }
     return copy;
   }
+  if (meter)
+    meter.bytes += typeof value === "string" ? 2 * value.length : 8;
   return value;
 }
+function instanceBytes(value, seen) {
+  if (typeof value === "string")
+    return 2 * value.length;
+  if (!value || typeof value !== "object")
+    return 8;
+  if (seen.has(value))
+    return 0;
+  seen.add(value);
+  if (ArrayBuffer.isView(value))
+    return value.byteLength;
+  if (value instanceof ArrayBuffer)
+    return value.byteLength;
+  let bytes = 32;
+  for (const entry of Object.values(value))
+    bytes += 16 + instanceBytes(entry, seen);
+  return bytes;
+}
 function contentKey(value) {
   const plain = (entry) => {
     if (ArrayBuffer.isView(entry)) {
@@ -20012,7 +20503,7 @@ function rebuildFileContent(value, output, attachments) {
     rebuilt.unshift({ type: "text", text: output });
   return { type: "content", value: rebuilt };
 }
-function adaptPayload(draft, admittedIDs = new Set) {
+function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map, hiddenTimes = false) {
   const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
   const source = draft.messages.filter((m) => !existingHeads.has(m.id));
   const results = new Map;
@@ -20122,6 +20613,7 @@ function adaptPayload(draft, admittedIDs = new Set) {
         id: message.id,
         sessionID: draft.sessionID,
         role: message.role,
+        time: message.id ? messageTimes.get(message.id) : undefined,
         ...{
           providerID: draft.model.providerID,
           modelID: draft.model.id,
@@ -20130,7 +20622,19 @@ function adaptPayload(draft, admittedIDs = new Set) {
       },
       parts
     };
+    if (hiddenTimes && mapped.info.time !== undefined) {
+      const time = mapped.info.time;
+      delete mapped.info.time;
+      Object.defineProperty(mapped.info, "time", {
+        value: time,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    }
     originals.set(mapped, message);
+    if (isCoveredInstructionRow(message))
+      markCoveredInstructionRow(mapped.info);
     if (typeof message.id !== "string")
       bridgesByCarrier.set(mapped, byCallID);
     messages.push(mapped);
@@ -20487,24 +20991,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;
     }
@@ -20523,7 +21034,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;
@@ -20534,7 +21045,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" } : {}
     };
@@ -20562,13 +21073,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;
@@ -20576,9 +21124,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) {
@@ -20617,6 +21167,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,
@@ -20694,6 +21289,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();
       }
@@ -20720,7 +21316,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);
@@ -20744,6 +21341,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 = {}) {
@@ -20828,6 +21440,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);
@@ -20836,8 +21451,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);
   }
 }
@@ -20852,11 +21470,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;
@@ -22038,26 +22652,70 @@ function generateReplayAnchor(messages) {
     return;
   return { id, tail: clonePreservingInstances(messages.slice(index + 1)) };
 }
+var DEFAULT_GENERATE_REPLAY_LIMITS = Object.freeze({
+  maxSessions: 16,
+  sessionMaxBytes: 128 * 1024 * 1024,
+  totalMaxBytes: 256 * 1024 * 1024
+});
 
 class V2GenerateReplay {
   prefixes = new Map;
+  totalBytes = 0;
+  limits;
+  constructor(limits = DEFAULT_GENERATE_REPLAY_LIMITS) {
+    if (!Number.isSafeInteger(limits.maxSessions) || limits.maxSessions < 1 || !Number.isSafeInteger(limits.sessionMaxBytes) || limits.sessionMaxBytes < 1 || !Number.isSafeInteger(limits.totalMaxBytes) || limits.totalMaxBytes < 1)
+      throw new Error("Generate replay limits must be positive integers");
+    this.limits = { ...limits };
+  }
   capture(draft, anchor) {
+    this.forget(draft.sessionID);
     if (!anchor) {
-      this.prefixes.delete(draft.sessionID);
       sessionLog(draft.sessionID, "generate replay capture skipped: no-anchor");
       return;
     }
+    const parts = {
+      anchor: clonePreservingInstancesMeasured(anchor),
+      system: clonePreservingInstancesMeasured(draft.system),
+      messages: clonePreservingInstancesMeasured(draft.messages),
+      tools: clonePreservingInstancesMeasured(draft.tools)
+    };
+    const bytes = 256 + parts.anchor.bytes + parts.system.bytes + parts.messages.bytes + parts.tools.bytes;
+    if (bytes > this.limits.sessionMaxBytes || bytes > this.limits.totalMaxBytes) {
+      sessionLog(draft.sessionID, `generate replay capture skipped: over-session-cap (${bytes} > ${Math.min(this.limits.sessionMaxBytes, this.limits.totalMaxBytes)} bytes)`);
+      return;
+    }
+    while (this.prefixes.size > 0 && (this.prefixes.size >= this.limits.maxSessions || this.totalBytes + bytes > this.limits.totalMaxBytes)) {
+      const oldest = this.prefixes.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.forget(oldest);
+    }
     this.prefixes.set(draft.sessionID, {
-      anchor: clonePreservingInstances(anchor),
+      anchor: parts.anchor.copy,
       model: `${draft.model.providerID}/${draft.model.id}`,
       agent: draft.agent,
-      system: clonePreservingInstances(draft.system),
-      messages: clonePreservingInstances(draft.messages),
-      tools: clonePreservingInstances(draft.tools)
+      system: parts.system.copy,
+      messages: parts.messages.copy,
+      tools: parts.tools.copy,
+      bytes
     });
+    this.totalBytes += bytes;
   }
   forget(sessionID) {
+    const prefix = this.prefixes.get(sessionID);
+    if (!prefix)
+      return;
     this.prefixes.delete(sessionID);
+    this.totalBytes -= prefix.bytes;
+  }
+  stats() {
+    return {
+      totalBytes: this.totalBytes,
+      sessions: [...this.prefixes].map(([sessionId, prefix]) => ({
+        sessionId,
+        bytes: prefix.bytes
+      }))
+    };
   }
   apply(draft) {
     const prefix = this.prefixes.get(draft.sessionID);
@@ -22067,6 +22725,8 @@ class V2GenerateReplay {
     };
     if (!prefix)
       return skip("no-prefix");
+    this.prefixes.delete(draft.sessionID);
+    this.prefixes.set(draft.sessionID, prefix);
     if (prefix.model !== `${draft.model.providerID}/${draft.model.id}`)
       return skip("model-mismatch");
     if (prefix.agent !== draft.agent)
@@ -22110,21 +22770,25 @@ function identity(slot) {
 
 class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
-  capture(sessionId, slot, input, served) {
+  capture(sessionId, slot, input, served, head) {
     this.systems.set(sessionId, {
       slot: identity(slot),
-      input: JSON.stringify(input),
-      served: structuredClone(served)
+      input: hostInputKey(input),
+      served: structuredClone(served),
+      head: head ? structuredClone(head) : null
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
-      return false;
+    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== hostInputKey(input))
+      return;
     target.splice(0, target.length, ...structuredClone(saved.served));
-    return true;
+    return { head: saved.head ? structuredClone(saved.head) : null };
   }
 }
+function hostInputKey(input) {
+  return JSON.stringify({ system: input.system, checkpoint: input.checkpoint });
+}
 
 // src/v2/hooks/model-limit-cache.ts
 var warmStarted = false;
@@ -22785,6 +23449,22 @@ function* readV2RawMessagePagesForConversion(openReader, sessionID, pageRows = C
 function createV2RawMessageReader(openReader) {
   const servedBoundaryCache = new Map;
   return {
+    getRevision: (sessionID) => {
+      const reader = openReader();
+      try {
+        return reader.latestSequence(sessionID);
+      } finally {
+        reader.close();
+      }
+    },
+    getCountAfterRevision: (sessionID, after, through) => {
+      const reader = openReader();
+      try {
+        return reader.messageCountAfterSequence(sessionID, after, through);
+      } finally {
+        reader.close();
+      }
+    },
     readPage: (sessionID, afterOrdinal, limit, finalWatermark, after) => {
       const reader = openReader();
       try {
@@ -24252,7 +24932,7 @@ function createCtxReduceTool(deps) {
       args = unwrapImitatedReducedArgs(args, ["drop"], { drop: "string" });
       const sessionId = toolContext.sessionID;
       if (!args.drop) {
-        return "Error: 'drop' must be provided.";
+        return `Error: 'drop' must be provided as a string of tag numbers, for example {"drop": "3-5,8"}.`;
       }
       let dropIds = [];
       try {
@@ -24634,6 +25314,26 @@ function persistV2UsageReading(args) {
 }
 
 // src/v2/hooks/context.ts
+function applyCheckpointHead(draft, head) {
+  const { checkpoint, submitted } = head;
+  const first = draft.messages.find((message) => message.id === HEAD_IDS[0]);
+  const baseline = first?.content.find((part) => part.type === "text")?.text;
+  if (typeof baseline !== "string")
+    return false;
+  for (const part of checkpoint.content)
+    if (part.type === "text" && typeof part.text === "string") {
+      part.text = part.text.replace(`<summary>
+${submitted}
+</summary>`, `<summary>
+${baseline}
+</summary>`);
+    }
+  const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
+  if (volatile && first)
+    volatile.content.push(...first.content.filter((part) => part.type !== "text"));
+  draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== first));
+  return true;
+}
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
 var STORE_POOL_DISPOSE_WAIT_MS = 1000;
 
@@ -24857,11 +25557,12 @@ async function registerContext(context) {
   }
   const folds = new FoldOwner(context.storage);
   const nativeFoldMemory = !compactionOff && process.env.MMC_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;
   const hiddenSessionErrors = new Map;
+  const committedSourceRefreshes = new Map;
   const liveModels = new Map;
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode2",
@@ -25061,11 +25762,17 @@ async function registerContext(context) {
     }
   });
   const pagedRead = createV2RawMessageReader(openStoreReader);
+  let orphanSweep;
+  let orphanSweepTimer;
   const prepareHistorySession = (sessionID) => {
     if (!rawProviders.has(sessionID))
       rawProviders.set(sessionID, setBoundedRawMessageProvider2(sessionID, createV2RawMessageProvider(pagedRead, sessionID)));
   };
   if (db && isDatabasePersisted(db)) {
+    const sweepDb = db;
+    orphanSweepTimer = scheduleAfterBootQuiet(() => {
+      orphanSweep = sweepOrphanedOpenCodeMessageIndexesCooperatively(sweepDb, () => new Database(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), { readonly: true, fileMustExist: true })).catch((error) => log("[magic-context] v2 orphan sweep failed:", error));
+    });
     const backfillDb = db;
     scheduleAfterBootQuiet(() => {
       runV2SessionProjectBackfill(backfillDb, openStoreReader, config.allow_home_project).catch((error) => log("[session-project-backfill] OpenCode 2 backfill failed:", error));
@@ -25184,88 +25891,122 @@ 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?.startsWith("session.revert.") && db) {
-          const database = db;
-          withoutSqliteTransformPass(() => scheduleClearAndReindex(database, sessionID, pagedRead));
-        }
-        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.revert.committed") {
+              committedSourceRefreshes.set(sessionID, {});
+              const database = db;
+              if (database)
+                withoutSqliteTransformPass(() => scheduleClearAndReindex(database, sessionID, pagedRead));
+            }
+            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) {
+                  log("[magic-context] v2 latest-thinking recovery arm failed", armError);
+                }
+              }
+              continue;
+            }
+            if (event.type === "session.deleted") {
+              committedSourceRefreshes.delete(sessionID);
+              clearLkgMeasuredRequest(sessionID);
+              deletedSessions.add(sessionID);
+              transform?.clearSessionLogState(sessionID);
+              if (db) {
+                markSessionCleanupPending(db, sessionID);
+                clearSession(db, sessionID, false, true);
+              }
+              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);
+              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);
+              clearMaintenanceSystemSnapshot(sessionID);
+              tagger.cleanup(sessionID);
+              sessionDirectories.delete(sessionID);
+              forkSeedSettled.delete(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) {
-              log("[magic-context] v2 latest-thinking recovery arm failed", armError);
+              if (!compactionOff && typeof await nativeFoldReplay?.baseline(sessionID) === "string")
+                hostFolds?.idle(sessionID);
             }
+          } catch (error) {
+            log(`[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);
-          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);
-          clearMaintenanceSystemSnapshot(sessionID);
-          tagger.cleanup(sessionID);
-          sessionDirectories.delete(sessionID);
-          forkSeedSettled.delete(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)
+          log("[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)
-        log("[magic-context] v2 usage subscription failed", error);
     }
   })();
   const materialize = (draft) => {
@@ -25338,20 +26079,57 @@ async function registerContext(context) {
       reader.close();
     }
   });
+  const restoreAfterCheckpoint = (args) => {
+    const { db, reader, draft, cut, boundaryRepair } = args;
+    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 = servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
+    const present = new Set(args.messages.map((message) => message.id));
+    const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: (detail) => sessionLog(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
+    } : undefined));
+    const covered = reader.instructionRowsThrough(draft.sessionID, Math.min(boundary, cut.seq)).flatMap((row) => restoreRow(row, draft.model)).map((message) => markCoveredInstructionRow(message));
+    return [
+      ...covered,
+      ...restored,
+      ...args.messages.filter((message) => message !== args.incoming)
+    ];
+  };
+  const temporalTimes = config.temporal_awareness === true;
+  const anchorTimesOnly = !temporalTimes;
+  const timeIds = (messages) => {
+    if (temporalTimes)
+      return messages.flatMap((message) => message.id ? [message.id] : []);
+    const ids = [];
+    for (const message of [...messages].reverse()) {
+      if (message.id)
+        ids.push(message.id);
+      if (message.role === "assistant")
+        break;
+    }
+    return ids;
+  };
   const runManagedContext = async (draft) => {
     rememberHostMedia(draft.messages);
     if (hiddenChildHook.apply(draft))
       return;
     if (deletedSessions.has(draft.sessionID))
       return;
-    const systemAtEntry = structuredClone(draft.system);
+    let systemAtEntry = structuredClone(draft.system);
     const slotAtEntry = getSlot(draft.sessionID);
+    let checkpointAtEntry;
+    let replayHead;
+    const hostInput = () => checkpointAtEntry === undefined ? undefined : { system: systemAtEntry, checkpoint: checkpointAtEntry };
     const restoreLkgSystem = () => {
       retirePendingSystemPromptDelivery(draft.sessionID);
-      if (!lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), systemAtEntry, draft.system)) {
+      const input = hostInput();
+      const restored = input && lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, draft.system);
+      if (!restored) {
         sessionLog(draft.sessionID, "lkg_system_state_mismatch");
         throw new Error("LKG system identity is unavailable or changed");
       }
+      replayHead = restored.head;
     };
     const isMagicContextSynthetic = (id) => isAdmittedSynthetic(context, draft.sessionID, id);
     const newest = draft.messages.at(-1);
@@ -25360,6 +26138,24 @@ async function registerContext(context) {
       return;
     }
     await dropStorageNotices(draft.messages, isMagicContextSynthetic);
+    let hostMessagesAtEntry = [...draft.messages];
+    const passTimes = new Map;
+    const readTimes = (reader, messages) => {
+      const ids = timeIds(messages);
+      const missing = ids.filter((id) => !passTimes.has(id));
+      if (missing.length) {
+        const read = reader.messageTimes(draft.sessionID, missing);
+        for (const id of missing)
+          passTimes.set(id, read.get(id) ?? null);
+      }
+      const times = new Map;
+      for (const id of ids) {
+        const time = passTimes.get(id);
+        if (time)
+          times.set(id, time);
+      }
+      return times;
+    };
     liveModels.set(draft.sessionID, {
       providerID: draft.model.providerID,
       modelID: draft.model.id
@@ -25371,8 +26167,9 @@ async function registerContext(context) {
     applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface);
     const admissionDb = db ?? storage.current();
     const replayFits = (messages) => {
-      const system = structuredClone(draft.system);
-      if (!admissionDb || !draft.tools || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), draft.system, system))
+      const system = [];
+      const input = hostInput();
+      if (!admissionDb || !draft.tools || !input || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, system))
         return false;
       const limit = lkgReplayLimit({
         db: admissionDb,
@@ -25407,15 +26204,75 @@ async function registerContext(context) {
         })
       }).fit === "under";
     };
+    const buildReplayInput = async () => {
+      let messages = [...hostMessagesAtEntry];
+      const admitted = new Set;
+      let times;
+      try {
+        const reader = openStoreReader();
+        try {
+          const cut = reader.latestCompaction(draft.sessionID);
+          const localCut = cut && isLocalCheckpoint(cut) ? cut : undefined;
+          const incoming = localCut && messages.find((message) => message.id === localCut.id);
+          if (localCut && !incoming || cut && nativeFoldReplay)
+            return;
+          checkpointAtEntry = incoming || null;
+          const modeDb = db ?? storage.current();
+          const subagent = modeDb ? storedSubagentMode(modeDb, draft.sessionID) : undefined;
+          if (subagent === undefined)
+            return;
+          if (subagent)
+            removePrimaryOnlyTools(draft.tools);
+          const candidates = syntheticCandidates(context, draft.sessionID, reader.syntheticMessageIDs(draft.sessionID));
+          for (const message of messages)
+            if (message.id && candidates.has(message.id) && await isAdmittedSynthetic(context, draft.sessionID, message.id))
+              admitted.add(message.id);
+          const replayDb = db ?? storage.current();
+          if (localCut && incoming && replayDb)
+            messages = restoreAfterCheckpoint({
+              db: replayDb,
+              reader,
+              draft,
+              messages,
+              cut: localCut,
+              incoming,
+              boundaryRepair: undefined
+            });
+          else if (localCut)
+            return;
+          times = readTimes(reader, messages);
+        } finally {
+          reader.close();
+        }
+      } catch (error) {
+        sessionLog(draft.sessionID, "lkg replay input unavailable", error);
+        return;
+      }
+      const replayDraft = { ...draft, messages };
+      return {
+        draft: replayDraft,
+        mapped: adaptPayload(replayDraft, admitted, times, anchorTimesOnly)
+      };
+    };
+    const adoptReplay = (replayed) => {
+      draft.messages.splice(0, draft.messages.length, ...replayed.messages);
+      if (replayHead)
+        applyCheckpointHead(draft, replayHead);
+    };
     let postFold = false;
     try {
       if (!compactionOff && admissionDb)
         await withAsyncPrivilegedWriter(admissionDb, () => {
           return;
         }, {
-          beforeRetry: (_error) => {
+          beforeRetry: async (_error) => {
+            hostMessagesAtEntry = [...draft.messages];
+            systemAtEntry = structuredClone(draft.system);
             let replayBlocked = false;
-            const mapped = adaptPayload(draft);
+            const input = await buildReplayInput();
+            if (!input)
+              return;
+            const { mapped } = input;
             try {
               const overflowDb = db;
               if (overflowDb !== undefined && overflowDb !== null && (isEmergencyRecoveryArmed(draft.sessionID) || getOverflowState(overflowDb, draft.sessionID).needsEmergencyRecovery)) {
@@ -25436,6 +26293,7 @@ async function registerContext(context) {
                   restoreLkgSystem();
                   mapped.messages.splice(0, mapped.messages.length, ...replay.messages);
                   mapped.commit();
+                  adoptReplay(input.draft);
                   sessionLog(draft.sessionID, "lkg_replay_served");
                   throw new V2LkgAdmissionReplay;
                 } else {
@@ -25452,6 +26310,8 @@ async function registerContext(context) {
               sessionLog(draft.sessionID, "lkg_replay_declined");
           }
         });
+      hostMessagesAtEntry = [...draft.messages];
+      systemAtEntry = structuredClone(draft.system);
       if (admissionDb)
         hideSubagentTools(draft, admissionDb);
       recordV2ToolDefinitions(draft);
@@ -25555,7 +26415,11 @@ async function registerContext(context) {
         contextUsageMap: usage,
         compactionOff,
         storeGeneration: "v2",
-        normalizeRestoredAssistantText: stripCopiedTagNotation,
+        normalizeRestoredAssistantText: (text, providerID) => {
+          const normalized = stripCopiedTagNotation(text);
+          return normalized === "" && !modelAcceptsEmptyContent(providerID) ? text : normalized;
+        },
+        refreshSourceContents: (sessionID) => committedSourceRefreshes.has(sessionID),
         hostCleanupCompactionMarkers: () => ({
           verified: true,
           removedLineages: 0,
@@ -25600,8 +26464,14 @@ async function registerContext(context) {
         },
         ...createHostSeams(context, readAllForConversion, pagedRead, liveModels)
       });
+      const refreshToken = committedSourceRefreshes.get(draft.sessionID);
+      if (refreshToken) {
+        clearCachedM0(db, draft.sessionID);
+        restoredRows.forget(draft.sessionID);
+      }
       const admitted = new Set;
       const reader = openStoreReader();
+      let messageTimes;
       let checkpoint;
       let submitted;
       try {
@@ -25616,12 +26486,14 @@ 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)
+        checkpointAtEntry = incoming || null;
+        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: true });
           } catch (error) {
@@ -25630,7 +26502,7 @@ 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)) {
           historyRefreshSessions.add(draft.sessionID);
           requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_history_change");
         }
@@ -25641,30 +26513,33 @@ 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) => {
-              log(`[magic-context] HARD reason=${reason} session=${draft.sessionID}`);
-              materialize(draft);
-              requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
-            }
-          });
-          checkpoint = structuredClone(identity.rendered ?? incoming);
-          submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
-          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 = servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
-          const present = new Set(draft.messages.map((message) => message.id));
-          const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
-            asset: hostMediaAsset,
-            unavailable: (detail) => sessionLog(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
-          } : undefined));
-          draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
+        } 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) => {
+                log(`[magic-context] HARD reason=${reason} session=${draft.sessionID}`);
+                materialize(draft);
+                requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
+              }
+            });
+            checkpoint = structuredClone(identity.rendered ?? incoming);
+            submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
+          }
+          draft.messages.splice(0, draft.messages.length, ...restoreAfterCheckpoint({
+            db,
+            reader,
+            draft,
+            messages: draft.messages,
+            cut: localCut,
+            incoming,
+            boundaryRepair
+          }));
         }
+        messageTimes = readTimes(reader, draft.messages);
       } finally {
         reader.close();
       }
@@ -25676,31 +26551,18 @@ async function registerContext(context) {
           nativeFoldReplay.invalidate(draft.sessionID, true);
         }
       }
-      const mapped = adaptPayload(draft, admitted);
+      const mapped = adaptPayload(draft, admitted, messageTimes, anchorTimesOnly);
       bindSystemDateRequestIdentity(mapped, draft);
       await transform({}, mapped);
       mapped.commit();
+      if (refreshToken && committedSourceRefreshes.get(draft.sessionID) === refreshToken)
+        committedSourceRefreshes.delete(draft.sessionID);
       if (db) {
         await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
       }
-      if (checkpoint && submitted !== undefined) {
-        const head = draft.messages.find((message) => message.id === HEAD_IDS[0]);
-        const baseline = head?.content.find((part) => part.type === "text")?.text;
-        if (typeof baseline === "string") {
-          for (const part of checkpoint.content)
-            if (part.type === "text" && typeof part.text === "string") {
-              part.text = part.text.replace(`<summary>
-${submitted}
-</summary>`, `<summary>
-${baseline}
-</summary>`);
-            }
-          const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
-          if (volatile && head)
-            volatile.content.push(...head.content.filter((part) => part.type !== "text"));
-          draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
-        }
-      }
+      const head = replayHead !== undefined ? replayHead : checkpoint && submitted !== undefined ? { checkpoint, submitted } : null;
+      const servedHead = head && structuredClone(head);
+      const headApplied = head ? applyCheckpointHead(draft, head) : false;
       if (nativeMessages && !checkpoint) {
         try {
           await nativeFoldReplay?.capture(draft, nativeMessages);
@@ -25711,7 +26573,7 @@ ${baseline}
       }
       const capturedSlot = getSlot(draft.sessionID);
       if (capturedSlot && (!slotAtEntry || capturedSlot.capturedAt !== slotAtEntry.capturedAt || capturedSlot.captureSequence !== slotAtEntry.captureSequence || capturedSlot.jsonPrefix !== slotAtEntry.jsonPrefix)) {
-        lkgSystems.capture(draft.sessionID, capturedSlot, systemAtEntry, draft.system);
+        lkgSystems.capture(draft.sessionID, capturedSlot, { system: systemAtEntry, checkpoint: checkpointAtEntry ?? null }, draft.system, headApplied ? servedHead : null);
       }
     } catch (error) {
       if (error instanceof V2ContextRefusal)
@@ -25737,7 +26599,10 @@ ${baseline}
               replayBlocked = true;
               sessionLog(draft.sessionID, "lkg_emergency_armed");
             } else {
-              const replayMapped = adaptPayload(draft);
+              const input = await buildReplayInput();
+              if (!input)
+                throw new StorageBusyRefusalError(error, "v2-context");
+              const replayMapped = input.mapped;
               const keys = resolveLkgModelKeys(replayMapped.messages);
               const replay = replayLkg({
                 sessionId: draft.sessionID,
@@ -25751,6 +26616,8 @@ ${baseline}
                 restoreLkgSystem();
                 replayMapped.messages.splice(0, replayMapped.messages.length, ...replay.messages);
                 replayMapped.commit();
+                adoptReplay(input.draft);
+                sessionLog(draft.sessionID, "lkg_replay_served");
                 return;
               } else {
                 sessionLog(draft.sessionID, replay.reason);
@@ -25895,13 +26762,17 @@ ${baseline}
   }, 0);
   return {
     async dispose() {
+      usageController.abort();
+      if (orphanSweepTimer)
+        clearTimeout(orphanSweepTimer);
       await hiddenCompletionExecutor?.dispose();
+      await usageDone;
+      await orphanSweep;
       rpcStopped = true;
       rpcServer.stop();
       tools?.dispose();
-      usageController.abort();
-      await usageDone;
       deletedSessions.clear();
+      committedSourceRefreshes.clear();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();