@retaw106/mmc-oc 2.4.0 → 2.6.0

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

@@ -72,15 +72,9 @@ import {
   clearMemoryVerifications,
   queueMemoryMutation,
   scheduleAfterBootQuiet,
-  BoundedSessionMap,
-  registerOwnRpcServerInstance,
-  rpcPortDir,
-  rpcPortFilePath,
-  parseRpcPortFile,
-  inspectProcessesAsync,
-  dirtyLkgRecoveryRevision,
-  ownsLkgDirtyFence,
-  invalidateCleanLkgRecoveryFence,
+  cleanSearchText,
+  keywordRelevance,
+  matchedSearchSnippet,
   getLastIndexedOrdinal,
   getIndexedMessageIdAtOrdinal,
   getIndexedMessageCorpusSize,
@@ -88,6 +82,11 @@ import {
   isMessageIndexReconciledThrough,
   clearIndexedMessages,
   indexMessagesAfterOrdinal,
+  registerOwnRpcServerInstance,
+  rpcPortDir,
+  rpcPortFilePath,
+  parseRpcPortFile,
+  inspectProcessesAsync,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -95,7 +94,8 @@ import {
   getMaxM0MutationId,
   ensureSessionMetaRow,
   clearCachedM0M1,
-  getCompartments,
+  clearCachedM0,
+  getTableColumnNames,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
   getAuthorityManagedMarker,
@@ -155,6 +155,7 @@ import {
   clearEmergencyRecovery,
   clearDetectedContextLimit,
   getPersistedCompactionMarkerState,
+  clearCompactionMarkerPublicationIntent,
   setPersistedCompactionMarkerState,
   getDeferredClearedCompactionMarkerState,
   retireDeferredClearedCompactionMarkerState,
@@ -183,6 +184,9 @@ import {
   resolveEpochFloorForPass,
   providerResponseFailed,
   isSuccessfulProviderCompletion,
+  dirtyLkgRecoveryRevision,
+  ownsLkgDirtyFence,
+  invalidateCleanLkgRecoveryFence,
   rememberUnpublishedAutoSearchNoHint,
   getUnpublishedAutoSearchNoHint,
   forgetUnpublishedAutoSearchNoHint,
@@ -221,6 +225,7 @@ import {
   lkgDirtyRevision,
   readLkgRecoveryPrefix,
   noteLkgHealthyPrefix,
+  lkgInputIdentity,
   beginLkgPass,
   getInMemorySlot,
   getSlot,
@@ -272,6 +277,7 @@ import {
   HISTORIAN_RECOMP_AGENT,
   HISTORIAN_EDITOR_AGENT,
   runTokenLog,
+  shouldWaitForNewHistorianHistory,
   extractM0Block,
   TEMPORAL_MARKER_REPLAY_PATTERN,
   collectTemporalCandidates,
@@ -292,6 +298,7 @@ import {
   prepareCachedM0M1Replay,
   hasCompleteCachedM0M1,
   injectM0M1,
+  omitIncompleteFileTokenTotals,
   RECOVERY_NO_HEAD_LIMIT,
   deriveProtectedTailTokenTarget,
   selectPerRunCap,
@@ -301,7 +308,7 @@ import {
   recordHighPressureNoEligibleHead,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-kahkxcqw.js";
+} from "./index-xk1dz6q9.js";
 import {
   getHarness,
   getDataDir,
@@ -429,19 +436,24 @@ import {
   pickNearestPriorOwner,
   expandToolPart,
   markHostUnservedRow,
+  isHostRenderedSystemMessage,
+  markCoveredInstructionRow,
+  isCoveredInstructionRow,
+  takeCoveredInstructionRows,
+  cloneKeepingCoveredInstructionMarks,
   estimateTrueRawMessageTokens,
   stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
-  buildFileSourceContent,
   toolPartHasUserAnswer,
   recordToolParameters,
   createDroppedInputGuard,
   assertExecutableToolInput,
   isEditTool,
+  BoundedSessionMap,
+  recordToolDefinitionSet,
   getCurrentToolSetHash,
-  recordToolDefinition,
   getMeasuredToolDefinitionTokens,
   describeFinalWireTail,
   estimatePartImageTokens,
@@ -477,7 +489,7 @@ import {
   hasRawSessionMessageById2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-48e9znrc.js";
+} from "./index-t0zx3tgz.js";
 import {
   normalizeModelEntry2,
   resolveHistorianModel2
@@ -492,7 +504,7 @@ import {
   withAsyncPrivilegedWriter,
   indexCoordinationInput,
   withIndexChunk
-} from "./index-dwh99z66.js";
+} from "./index-pte3cfs9.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -509,7 +521,7 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-ykq24x1n.js";
+} from "./index-8rmt6s4f.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -522,11 +534,14 @@ import {
   getErrorMessage,
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./index-r7s7d350.js";
+} from "./index-s3ebcy63.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 +5056,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 +5140,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 +5185,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 +5209,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 +5262,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 +5280,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;
@@ -6316,6 +6372,26 @@ class EmergencyFailClosedError extends Error {
 }
 
 // src/hooks/magic-context/history-boundary-repair.ts
+function readStoreBoundaries(db, sessionId) {
+  const columns = getTableColumnNames(db, "compartments");
+  const numbers = ["id", "sequence", "start_message", "end_message", "created_at"];
+  const strings = ["session_id", "start_message_id", "end_message_id", "title", "content"];
+  const predicates = [...numbers, ...strings].every((column) => columns.has(column)) ? [
+    ...numbers.map((column) => `typeof(${column}) IN ('integer', 'real')`),
+    ...strings.map((column) => `typeof(${column}) = 'text'`)
+  ] : ["0"];
+  for (const column of ["p1", "p2", "p3", "p4", "episode_type"]) {
+    if (columns.has(column))
+      predicates.push(`typeof(${column}) IN ('text', 'null')`);
+  }
+  for (const column of ["importance", "legacy"]) {
+    if (columns.has(column))
+      predicates.push(`typeof(${column}) IN ('integer', 'real', 'null')`);
+  }
+  return db.prepare(`SELECT sequence, ${columns.has("end_message_id") ? "end_message_id" : "NULL"} AS endMessageId
+             FROM compartments WHERE session_id = ? AND ${predicates.join(" AND ")}
+             ORDER BY sequence ASC`).all(sessionId);
+}
 function readBaseline(db, sessionId) {
   const row = db.prepare("SELECT cached_m0_bytes IS NOT NULL AS hasM0, cached_m0_last_baseline_end_message_id AS boundary FROM session_meta WHERE session_id = ?").get(sessionId);
   return {
@@ -6381,7 +6457,7 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = f
 }
 function repairMissingHistoryBoundary(args) {
   const { db, sessionId, isInHostStore, scope = "store" } = args;
-  const compartments = scope === "active-branch" ? db.prepare("SELECT sequence, COALESCE(end_message_id, '') AS endMessageId FROM compartments WHERE session_id = ? ORDER BY sequence").all(sessionId) : getCompartments(db, sessionId);
+  const compartments = scope === "active-branch" ? db.prepare("SELECT sequence, COALESCE(end_message_id, '') AS endMessageId FROM compartments WHERE session_id = ? ORDER BY sequence").all(sessionId) : readStoreBoundaries(db, sessionId);
   let latestIndex = compartments.length - 1;
   while (latestIndex >= 0 && !compartments[latestIndex]?.endMessageId)
     latestIndex -= 1;
@@ -6425,7 +6501,7 @@ function repairMissingHistoryBoundary(args) {
     let dropped;
     let anchorForDrop = anchor;
     try {
-      if (scope === "active-branch" && anchor) {
+      if (anchor) {
         const row = db.prepare("SELECT end_message AS endMessage FROM compartments WHERE session_id = ? AND sequence = ?").get(sessionId, anchor.sequence);
         if (!row)
           return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
@@ -7200,7 +7276,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 +7351,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 +7668,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 +7723,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 +8348,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 +8374,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 +8397,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 +8677,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 +8704,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 +8776,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 +8988,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 +10475,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 +10574,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 +10597,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 +10615,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 +10623,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 +10667,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 +10744,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 +10787,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 +10798,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 +10858,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 +10872,7 @@ function createSystemPromptHashHandler(deps) {
   return {
     handler,
     clearSession: (sessionId) => {
+      recordedStickyDateBySession.delete(sessionId);
       clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
@@ -11203,6 +11384,8 @@ function reconcileCompactionMode(args) {
     return NO_TRANSITION;
   if (stored === "off_cleanup_pending") {
     const markerCleanup = (args.cleanupMarkers ?? cleanupOffMarkers)(sessionId);
+    if (markerCleanup.verified)
+      clearCompactionMarkerPublicationIntent(db, sessionId);
     return {
       ...NO_TRANSITION,
       recordToWrite: markerCleanup.verified ? "off" : null,
@@ -11217,7 +11400,9 @@ function reconcileCompactionMode(args) {
   if (markerCleanup.removedRows > 0)
     clearedSomething = true;
   if (getPersistedCompactionMarkerState(db, sessionId) !== null) {
-    setPersistedCompactionMarkerState(db, sessionId, null);
+    setPersistedCompactionMarkerState(db, sessionId, null, {
+      preservePending: !markerCleanup.verified
+    });
     clearedSomething = true;
   }
   const pendingMarker = getPendingCompactionMarkerState(db, sessionId);
@@ -11760,6 +11945,13 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     }
     return { shouldFire: false };
   }
+  if (tailInfo.boundarySnapshot && shouldWaitForNewHistorianHistory(tailInfo.boundarySnapshot, {
+    usagePercentage: usage.percentage,
+    emergency: getOverflowState(db, sessionId).needsEmergencyRecovery
+  })) {
+    sessionLog(sessionId, "compartment trigger: waiting for new history after no forward progress");
+    return { shouldFire: false };
+  }
   const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
   const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff, eligiblePendingDropTagIds);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
@@ -11867,6 +12059,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",
@@ -11942,6 +12136,27 @@ function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, execu
   }) / 100) * historyBudgetPercentage);
 }
 
+// src/hooks/magic-context/signed-thinking-fit-snapshot.ts
+function takeSignedThinkingFitSnapshot(args) {
+  let snapshot = null;
+  if (args.held && !args.compactionOff) {
+    try {
+      snapshot = cloneKeepingCoveredInstructionMarks(args.entryOrder);
+    } catch (error) {
+      sessionLog(args.sessionId, `signed thinking fit: could not copy the pass input (${error instanceof Error ? error.message : String(error)}); an over-window held request will be refused rather than retried`);
+    }
+  }
+  snapshotObserver?.({
+    sessionId: args.sessionId,
+    held: args.held,
+    activeAnthropicThinkingTurn: args.activeAnthropicThinkingTurn,
+    compactionOff: args.compactionOff,
+    snapshot
+  });
+  return snapshot;
+}
+var snapshotObserver;
+
 // src/hooks/magic-context/temporal-served-projection.ts
 function readLkgTemporalDecisions(db, sessionId, runtime) {
   const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
@@ -12165,7 +12380,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 +12597,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);
     }
   }
@@ -12439,28 +12654,52 @@ var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
+var FROZEN_TEXT_ANNOTATION_SUFFIX = /(?:\n\n(?:<instruction name="deferred_notes">(?:(?!<\/instruction>)[\s\S])*<\/instruction>|<ctx-search-hint>(?:(?!<\/ctx-search-hint>)[\s\S])*<\/ctx-search-hint>))+$/;
+function renderDroppedText(tagId, renderedText) {
+  const placeholder = buildReplacementContent(tagId);
+  if (renderedText?.startsWith(placeholder))
+    return renderedText;
+  const annotations = renderedText?.match(FROZEN_TEXT_ANNOTATION_SUFFIX)?.[0] ?? "";
+  return placeholder + annotations;
+}
 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;
@@ -12504,6 +12743,7 @@ function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options =
                 AND drop_mode IN ('truncated', 'full')
               ORDER BY tag_number`).all(sessionId);
   const rows = readRows(db);
+  options.prepareRemovals?.(rows);
   const identity = JSON.stringify(rows);
   const converted = new Map;
   for (const row of rows) {
@@ -12542,174 +12782,250 @@ function renderConvertedToolSkeletons(targets, converted) {
   }
   return didMutate;
 }
+var PENDING_OPERATION_CHUNK_SIZE = 64;
+var PENDING_OPERATION_REJECTED_LOG_CHUNK = 20;
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
   let diagnostics;
-  const reject = (reason) => {
+  const reject = (tagNumber, reason, state = {}) => {
     if (!diagnostics)
       return;
     diagnostics.reasons[reason] = (diagnostics.reasons[reason] ?? 0) + 1;
+    const persisted = state.persisted === true;
+    (diagnostics.rejected ??= []).push({
+      tagNumber,
+      reason,
+      persisted,
+      queueState: state.queueState ?? (persisted ? "removed" : "retained")
+    });
   };
   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(pendingOp.tagId, "already_reduced", {
+                queueState: synthetic ? "none" : "removed"
+              });
               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(pendingOp.tagId, "drop_incomplete", {
+                queueState: synthetic ? "none" : "retained"
+              });
               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(pendingOp.tagId, veto, {
+                queueState: synthetic ? "none" : "retained"
+              });
               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(pendingOp.tagId, "synthetic_non_tool", {
+                  queueState: "none"
+                });
+                continue;
+              }
+              if (target?.canDrop?.() !== true) {
+                reject(pendingOp.tagId, "synthetic_target_not_droppable", {
+                  queueState: "none"
+                });
+                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(pendingOp.tagId, "edit_marker_incomplete", {
+                    queueState: synthetic ? "none" : "retained"
+                  });
+                  continue;
+                }
+                persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
+                mutations.push(() => {
+                  const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
+                  if (markResult === "incomplete" || markResult === "absent") {
+                    reject(pendingOp.tagId, `edit_marker_${markResult}`, {
+                      persisted: true,
+                      queueState: synthetic ? "none" : "removed"
+                    });
+                    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(pendingOp.tagId, "drop_incomplete", {
+                    queueState: synthetic ? "none" : "retained"
+                  });
+                  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(pendingOp.tagId, `drop_${dropResult}`, {
+                      persisted: true,
+                      queueState: synthetic ? "none" : "removed"
+                    });
+                    return;
+                  }
+                  if (dropResult === "removed" || dropResult === "truncated") {
+                    record(true);
+                    onTagReduced?.({
+                      tagNumber: pendingOp.tagId,
+                      mode: appliedMode === "full" ? "full" : "truncated"
+                    });
+                  } else {
+                    reject(pendingOp.tagId, `drop_${dropResult}`, {
+                      persisted: true,
+                      queueState: synthetic ? "none" : "removed"
+                    });
+                    record(false);
+                  }
+                });
+              }
+            } else if (target) {
+              const replacement = renderDroppedText(pendingOp.tagId, target.getContent?.());
+              if (target.canSetContent?.(replacement) === false) {
+                reject(pendingOp.tagId, "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(pendingOp.tagId, "content_unchanged", {
+                    persisted: true,
+                    queueState: "removed"
+                  });
+                }
               });
-            } else {
-              reject(`drop_${dropResult}`);
+            } else if (!synthetic) {
+              persistDrop();
+              reject(pendingOp.tagId, "target_absent", {
+                persisted: true,
+                queueState: "removed"
+              });
+              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) {
       const reasons = Object.entries(diagnostics.reasons).sort(([left], [right]) => left.localeCompare(right)).map(([reason, count]) => `${reason}:${count}`).join(",");
       sessionLog(sessionId, `pending operations no-op: source=${diagnostics.source} total=${diagnostics.total} persisted=${diagnostics.persistedWithoutMutation} reasons=${reasons || "none"}`);
     }
+    const rejected = diagnostics.rejected;
+    if (rejected && rejected.length > 0) {
+      const lineCount = Math.ceil(rejected.length / PENDING_OPERATION_REJECTED_LOG_CHUNK);
+      for (let offset = 0;offset < rejected.length; offset += PENDING_OPERATION_REJECTED_LOG_CHUNK) {
+        const entries = rejected.slice(offset, offset + PENDING_OPERATION_REJECTED_LOG_CHUNK).map((entry) => `${entry.tagNumber}:${entry.reason}:${entry.queueState}${entry.persisted ? ":persisted" : ""}`).join(",");
+        const chunkLabel = lineCount > 1 ? ` chunk=${Math.floor(offset / PENDING_OPERATION_REJECTED_LOG_CHUNK) + 1}/${lineCount}` : "";
+        sessionLog(sessionId, `pending operations rejected: source=${diagnostics.source} total=${diagnostics.total} mutated=${diagnostics.mutated} persisted=${diagnostics.persistedWithoutMutation}${chunkLabel} rejected=${entries}`);
+      }
+    }
   }
   return didMutateMessage;
 }
@@ -12750,7 +13066,7 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
           }
         }
       } else if (target) {
-        const changed = target.setContent(buildReplacementContent(tag.tagNumber));
+        const changed = target.setContent(renderDroppedText(tag.tagNumber, target.getContent?.()));
         if (changed)
           didMutateMessage = true;
       }
@@ -12937,10 +13253,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 +13665,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 +13696,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 +13754,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 +13780,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             return true;
           }
         });
-        fileOrdinal += 1;
       }
     }
     if (message.info.role === "assistant" && !messageHasTextPart) {
@@ -13461,6 +13808,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 +14738,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 +14923,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 +15000,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 +15026,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 +15034,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 +15049,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 +15087,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 +15115,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 +15149,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 +15184,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 +15303,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 +15711,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 +15762,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 +16043,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 +16548,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 +16571,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 entryOrderForThinkingFit = messages.slice();
+    const coveredHostInstructions = takeCoveredInstructionRows(messages);
     const passOutcome = createPassOutcome();
     const tSessionId = performance.now();
     const sessionId = findSessionId(messages);
@@ -16115,8 +16586,21 @@ function createTransform(deps) {
     const temporalReplayIds = temporalCandidates ? messages.flatMap((message) => message.info.id ? [message.info.id] : []) : undefined;
     logTransformTiming(sessionId, "findSessionId", tSessionId, `messages=${messages.length}`);
     const tLkgEntry = performance.now();
-    const lkgInput = projectEntry(sessionId, messages);
+    const lkgInput = projectEntry(sessionId, entryOrderForThinkingFit);
     const recovery = deps.compactionOff ? {} : readLkgRecoveryPrefix(sessionId, lkgInput, messages, deps.db);
+    const recoveryTailSources = [];
+    if (recovery.prefix) {
+      const priorIdentities = new Set(recovery.prefix.inputs.map((input) => input.id));
+      lkgInput.forEach((input, index) => {
+        const identity = lkgInputIdentity(input.id, input.role, index);
+        if (!identity || priorIdentities.has(identity))
+          return;
+        recoveryTailSources.push({
+          identity,
+          pristineSystem: input.id === null && input.role === "system" ? structuredClone(entryOrderForThinkingFit[index]) : undefined
+        });
+      });
+    }
     logTransformTiming(sessionId, "lkg.entryProjection", tLkgEntry, entryReuse ? `reused=${entryReuse.reused} retained=${entryReuse.retained} retainedBytes=${entryReuse.retainedBytes}` : undefined);
     const resolvedSessionId = sessionId;
     const runNotificationParams = (sid) => {
@@ -16199,6 +16683,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,
@@ -16417,6 +16902,13 @@ function createTransform(deps) {
     activeThinkingTurn ||= hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID);
     activeThinkingPrefixHold ||= activeThinkingTurn && isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID);
     freezeM0M1 ||= activeThinkingPrefixHold;
+    const originalForThinkingFit = takeSignedThinkingFitSnapshot({
+      sessionId,
+      entryOrder: entryOrderForThinkingFit,
+      held: activeThinkingPrefixHold,
+      activeAnthropicThinkingTurn: activeThinkingTurn,
+      compactionOff
+    });
     if (freezeM0M1 && prefixHoldLogTurnIds.get(sessionId) !== currentTurnId) {
       prefixHoldLogTurnIds.set(sessionId, currentTurnId);
       const reason = activeThinkingPrefixHold ? "active thinking turn (prefix-bound model)" : "session directory unresolved";
@@ -16441,7 +16933,8 @@ function createTransform(deps) {
           systemPromptTokens: sessionMeta.systemPromptTokens,
           providerID: modelForBudget?.providerID,
           modelID: modelForBudget?.modelID,
-          agentName: runNotificationParams(sessionId)?.agent
+          agentName: runNotificationParams(sessionId)?.agent,
+          sessionId
         });
         const incomingTokens = incoming.messageTokens.conversation + incoming.messageTokens.toolCall;
         if (unmanagedOverWindowCarried || isClearlyOverWindow(incomingTokens, resolvedContextLimit)) {
@@ -16627,8 +17120,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 +17171,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 +17201,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 +17237,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 +17319,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,
@@ -16925,7 +17422,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           systemPromptTokens: sessionMeta.systemPromptTokens,
           providerID: modelForBudget?.providerID,
           modelID: modelForBudget?.modelID,
-          agentName: notificationParams.agent
+          agentName: notificationParams.agent,
+          sessionId
         });
         contextUsage = resolveUnknownUsageFromWireEstimate({
           usage: contextUsage,
@@ -16989,6 +17487,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       fullFeatureMode,
       compactionOff,
       canRunCompartments,
+      hostInstructionRows: deps.storeGeneration === "v2",
       awaitedCompartmentRun,
       phaseJustAwaitedPublication: compartmentPhase.justAwaitedPublication,
       compartmentInProgress,
@@ -16997,6 +17496,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 +17526,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       emergencyCeilingTokens,
       pendingCompartmentInjection,
       prefixTrimSourceOrder,
+      coveredHostInstructions,
       hiddenMessagesAtCompactionSeam,
       trimmedMessagesAtCompactionBoundary,
       didMutateFromFlushedStatuses,
@@ -17053,9 +17554,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     });
     if (recovery.prefix && !recoveryNormalized) {
-      const priorIds = new Set(recovery.prefix.inputs.map((input) => input.id));
-      const newIds = new Set(lkgInput.flatMap((input) => input.id && !priorIds.has(input.id) ? [input.id] : []));
-      const suffix = messages.filter((message) => message.info.id && newIds.has(message.info.id));
+      const renderedById = new Map;
+      for (const message of messages) {
+        if (!message.info.id)
+          continue;
+        const group = renderedById.get(message.info.id) ?? [];
+        group.push(message);
+        renderedById.set(message.info.id, group);
+      }
+      const suffix = recoveryTailSources.flatMap(({ identity, pristineSystem }) => pristineSystem ? [pristineSystem] : renderedById.get(identity) ?? []);
       messages.splice(0, messages.length, ...JSON.parse(recovery.prefix.json), ...suffix);
     }
     const recoveryReleaseReason = recovery.rebuildReason ?? (recoveryNormalized ? "recovery_tail_normalized" : undefined);
@@ -17072,6 +17579,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           providerID: modelForBudget?.providerID,
           modelID: modelForBudget?.modelID,
           agentName: notificationParams.agent,
+          sessionId,
           systemPromptHash: sessionMeta.systemPromptHash
         }, boundaryContextLimit);
       } catch {
@@ -17086,13 +17594,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         providerID: modelForBudget?.providerID,
         modelID: modelForBudget?.modelID,
         agentName: notificationParams.agent,
+        sessionId,
         systemPromptHash: sessionMeta.systemPromptHash
       }, boundaryContextLimit) : undefined);
       if (finalWireEstimate) {
         sessionLog(sessionId, `transform: final-wire telemetry estimate=${finalWireEstimate.tokens} trusted=${finalWireEstimate.trusted} conversation=${finalWireEstimate.messageTokens.conversation} tools=${finalWireEstimate.messageTokens.toolCall} system=${finalWireEstimate.systemTokens} toolDefinitions=${finalWireEstimate.toolDefinitionTokens ?? "unknown"} tail=${finalWireTail}`);
       }
       if ((finalWireEstimate?.refusalGrade || finalWireEstimate?.refusalBasis === "byte-bound" && finalWireEstimate.refusalTokens !== undefined) && boundaryContextLimit > 0 && (finalWireEstimate.refusalTokens ?? finalWireEstimate.tokens) > boundaryContextLimit) {
-        if (!thinkingFitRetries.has(sessionId) && activeThinkingPrefixHold && originalForThinkingFit && hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID)) {
+        const signedFitRetryWanted = !thinkingFitRetries.has(sessionId) && activeThinkingPrefixHold && hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID);
+        if (signedFitRetryWanted && originalForThinkingFit) {
           thinkingFitRetries.add(sessionId);
           requestPendingMaterialization(deps.pendingMaterializationSessions, sessionId, "fit_retry");
           messages.splice(0, messages.length, ...originalForThinkingFit);
@@ -17103,7 +17613,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           }
           return;
         }
-        if (thinkingFitRetries.has(sessionId) || postTransformResult.thinkingReleasedForFit)
+        if (signedFitRetryWanted) {
+          sessionLog(sessionId, "signed thinking fit: the held request is over the window and no copy of the pass input exists to retry from; refusing it");
+        }
+        if (signedFitRetryWanted || thinkingFitRetries.has(sessionId) || postTransformResult.thinkingReleasedForFit)
           throw contextRefusalError("The request remains over the model window after stripping signed thinking and reclaiming context");
       }
       if (postTransformResult.prefixTrimStatus === "refused") {
@@ -17112,7 +17625,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           systemPromptTokens: sessionMeta.systemPromptTokens,
           providerID: modelForBudget?.providerID,
           modelID: modelForBudget?.modelID,
-          agentName: notificationParams.agent
+          agentName: notificationParams.agent,
+          sessionId
         });
         if (untrimmed.tokens > boundaryContextLimit) {
           sessionLog(sessionId, `history boundary unresolved: prefix trim refused and the untrimmed request estimate ${untrimmed.tokens} (trusted=${untrimmed.trusted}) exceeds the context limit ${boundaryContextLimit}; not sending it`);
@@ -17125,7 +17639,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           systemPromptTokens: sessionMeta.systemPromptTokens,
           providerID: modelForBudget?.providerID,
           modelID: modelForBudget?.modelID,
-          agentName: notificationParams.agent
+          agentName: notificationParams.agent,
+          sessionId
         });
         const servedTokens = served.toolDefinitionsMeasured ? served.rawTokens ?? served.tokens : Math.max(0, sessionMeta.systemPromptTokens) + served.messageTokens.conversation + served.messageTokens.toolCall;
         if (!Number.isFinite(servedTokens) || servedTokens > unmanagedOverWindowPass.limit) {
@@ -17203,7 +17718,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
             systemPromptTokens: sessionMeta.systemPromptTokens,
             providerID: modelForBudget?.providerID,
             modelID: modelForBudget?.modelID,
-            agentName: notificationParams.agent
+            agentName: notificationParams.agent,
+            sessionId
           });
         } catch (error) {
           sessionLog(sessionId, "degraded pass size guard could not estimate:", error);
@@ -17220,7 +17736,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 +17840,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 +17897,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 +17908,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
@@ -17412,6 +17931,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         providerID: modelForBudget?.providerID,
         modelID: modelForBudget?.modelID,
         agentName: notificationParams.agent,
+        sessionId,
         systemPromptHash: sessionMeta.systemPromptHash
       });
     try {
@@ -17428,7 +17948,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);
     }
@@ -17882,8 +18403,26 @@ WHERE session_id = ?
   AND data IS NOT NULL
   AND (time_created > ? OR (time_created = ? AND id > ?))
 ORDER BY time_created, id`;
-function readAssistantUsageRowsAfter(openCodeDb, sessionId, afterTimeCreated, afterId) {
-  const rows = openCodeDb.prepare(ASSISTANT_USAGE_ROWS_AFTER_SQL).all(sessionId, afterTimeCreated, afterTimeCreated, afterId);
+var V2_ASSISTANT_USAGE_ROWS_AFTER_SQL = `
+WITH newer AS (
+  SELECT id, seq, data FROM session_message
+  WHERE session_id = ? AND type = 'assistant' AND data IS NOT NULL AND seq > ?
+  UNION ALL
+  SELECT id, seq, data FROM session_message
+  WHERE session_id = ? AND type = 'assistant' AND data IS NOT NULL AND seq = ? AND id > ?
+)
+SELECT
+  json_extract(data, '$.agent') AS agent,
+  seq AS time_created,
+  id AS id,
+  COALESCE(json_extract(data, '$.tokens.input'), 0)
+    + COALESCE(json_extract(data, '$.tokens.cache.read'), 0)
+    + COALESCE(json_extract(data, '$.tokens.cache.write'), 0) AS prompt,
+  COALESCE(json_extract(data, '$.tokens.output'), 0) AS output
+FROM newer
+ORDER BY seq, id`;
+function readAssistantUsageRowsAfter(openCodeDb, sessionId, afterTimeCreated, afterId, generation = "v1") {
+  const rows = openCodeDb.prepare(generation === "v2" ? V2_ASSISTANT_USAGE_ROWS_AFTER_SQL : ASSISTANT_USAGE_ROWS_AFTER_SQL).all(...generation === "v2" ? [sessionId, afterTimeCreated, sessionId, afterTimeCreated, afterId] : [sessionId, afterTimeCreated, afterTimeCreated, afterId]);
   return rows.map((r) => ({
     agent: r.agent ?? null,
     timeCreated: Number(r.time_created ?? 0),
@@ -17892,8 +18431,8 @@ function readAssistantUsageRowsAfter(openCodeDb, sessionId, afterTimeCreated, af
     output: Number(r.output ?? 0)
   }));
 }
-function computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry) {
-  const rows = readAssistantUsageRowsAfter(openCodeDb, sessionId, carry.lastTimeCreated, carry.lastId);
+function computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry, generation = "v1") {
+  const rows = readAssistantUsageRowsAfter(openCodeDb, sessionId, carry.lastTimeCreated, carry.lastId, generation);
   if (rows.length === 0) {
     return { carry, metrics: metricsFromCarry(carry) };
   }
@@ -18091,13 +18630,15 @@ function resolveTailHygieneStatus(tsBaseline, rustBaseline) {
 // src/plugin/rpc-handlers.ts
 var workMetricsCarryBySession = new Map;
 function resolveSidebarWorkMetrics(db, sessionId, persistedNewWork, persistedTotalInput) {
-  if (!openCodeDbExists()) {
+  const generation = getHarness() === "opencode2" ? "v2" : "v1";
+  if (!openCodeDbExists(generation)) {
     return { newWorkTokens: persistedNewWork, totalInputTokens: persistedTotalInput };
   }
   try {
-    const carry = workMetricsCarryBySession.get(sessionId) ?? emptyWorkMetricsCarry();
-    const { carry: nextCarry, metrics } = withReadOnlySessionDb((openCodeDb) => computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry));
-    workMetricsCarryBySession.set(sessionId, nextCarry);
+    const carryKey = `${generation}:${sessionId}`;
+    const carry = workMetricsCarryBySession.get(carryKey) ?? emptyWorkMetricsCarry();
+    const { carry: nextCarry, metrics } = withReadOnlySessionDb((openCodeDb) => computeOpenCodeWorkMetricsIncremental(openCodeDb, sessionId, carry, generation), generation);
+    workMetricsCarryBySession.set(carryKey, nextCarry);
     try {
       setSessionWorkMetrics(db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
     } catch {}
@@ -18216,7 +18757,7 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       if (model) {
         activeProviderID = model.providerID;
         activeModelID = model.modelID;
-        measuredToolDefTokens = getMeasuredToolDefinitionTokens(model.providerID, model.modelID, agent) ?? 0;
+        measuredToolDefTokens = getMeasuredToolDefinitionTokens(model.providerID, model.modelID, agent, sessionId) ?? 0;
       }
     }
     const contextLimit = activeProviderID && activeModelID ? resolveContextLimit(activeProviderID, activeModelID, {
@@ -18702,8 +19243,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-51xyaexp.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-vdppp5x6.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -18752,7 +19293,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-g0mww1h4.js");
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -18840,8 +19381,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 +19649,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 +19723,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 +19754,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 +19789,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 +19797,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 +19811,7 @@ class MagicContextRpcServer {
     return this.port;
   }
   stop() {
+    this.stopped = true;
     for (const ws of this.sockets) {
       try {
         if (ws.data.authTimer)
@@ -19212,6 +19828,9 @@ class MagicContextRpcServer {
     try {
       unlinkSync(this.portFilePath);
     } catch {}
+    try {
+      rmdirSync(this.portDir);
+    } catch {}
     this.unregisterOwnInstance?.();
     this.unregisterOwnInstance = null;
   }
@@ -19369,17 +19988,17 @@ var FULL_PARAMETER_DESCRIPTIONS = {
     message: "Message ordinal from a <session-history> heading or a mmc_search hit, not a tag number. Returns that one message in full. Use alone."
   },
   mmc_note: {
-    action: "write | read | update | dismiss. Defaults to write when content is given, else read.",
+    action: "write | read | update | dismiss.",
     content: "Note text for write/update: first line is the title (under 80 chars), then the detail.",
     filter: "Read filter: active (default), all, dismissed.",
     limit: "Rows per read (default 25).",
     offset: "Skip this many newest rows (default 0).",
-    note_ids: "Note ids: one for update, 1–50 for dismiss or read (read returns full bodies). Ignored by write."
+    note_ids: "Note ids: one for update, 1–50 for dismiss, or 1–50 to read those notes in full. Write and a plain read take an empty list."
   },
   mmc_memory: {
     action: "write | update | archive | merge | get",
     content: "The memory text — one standalone fact (write, update, merge).",
-    category: "Kind of fact (required for write; on update/merge optional, omitted keeps the current category).",
+    category: "Kind of fact (required for write; on update/merge, pass the memory's current category to keep it).",
     ids: "Memory ids from <project-memory>: one for update, one or more for archive, two or more for merge, 1–20 for get.",
     reason: "Why it is being archived (optional)."
   },
@@ -19403,17 +20022,17 @@ var LIGHT_PARAMETER_DESCRIPTIONS = {
     message: "Message ordinal from a <session-history> heading or a mmc_search hit, not a tag number. Returns that one message in full. Use alone."
   },
   mmc_note: {
-    action: "write | read | update | dismiss (default: write with content, else read).",
+    action: "write | read | update | dismiss.",
     content: "Note text: first line title (<80 chars), then detail.",
     filter: "Read filter: active (default), all, dismissed.",
     limit: "Rows per read (default 25).",
     offset: "Skip newest rows (default 0).",
-    note_ids: "One id for update, 1–50 for dismiss or read (full bodies). Ignored by write."
+    note_ids: "One id for update, 1–50 for dismiss, or 1–50 to read those notes in full. Write and a plain read take an empty list."
   },
   mmc_memory: {
     action: "write | update | archive | merge | get",
     content: "One standalone fact (write, update, merge).",
-    category: "Kind of fact (required for write; optional on update/merge).",
+    category: "Kind of fact (required for write; on update/merge pass the current category to keep it).",
     ids: "Ids from <project-memory>: one for update, 1+ for archive, 2+ for merge, 1–20 for get.",
     reason: "Why it is archived (optional)."
   },
@@ -19945,18 +20564,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 +20669,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 +20779,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 +20788,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 +21157,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 +21200,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 +21211,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 +21239,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 +21290,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 +21333,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 +21455,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 +21482,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 +21507,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 +21606,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 +21617,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 +21636,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;
@@ -21813,6 +22593,96 @@ async function createV2HiddenCompletionExecutor(host, options) {
   };
 }
 
+// src/v2/message-times.ts
+function isSettled(entry, readAt) {
+  return (entry.version.type === "user" || entry.time.completed !== undefined) && typeof entry.version.updated === "number" && Number.isFinite(entry.version.updated) && entry.version.updated <= readAt - 1000;
+}
+function sameVersion(a, b) {
+  return a.type === b.type && a.seq === b.seq && a.created === b.created && a.updated === b.updated;
+}
+
+class V2MessageTimesCache {
+  capacity;
+  sessions = new Map;
+  constructor(capacity = 64) {
+    this.capacity = capacity;
+  }
+  delete(sessionID) {
+    this.sessions.delete(sessionID);
+  }
+  deleteMessage(sessionID, messageID) {
+    this.sessions.get(sessionID)?.entries.delete(messageID);
+  }
+  clear() {
+    this.sessions.clear();
+  }
+  pass(sessionID) {
+    const previous = this.sessions.get(sessionID);
+    const current = { entries: new Map };
+    this.sessions.delete(sessionID);
+    this.sessions.set(sessionID, current);
+    while (this.sessions.size > this.capacity) {
+      const oldest = this.sessions.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.sessions.delete(oldest);
+    }
+    const passTimes = new Map;
+    return (reader, ids) => {
+      const missing = [...new Set(ids)].filter((id) => !passTimes.has(id));
+      if (missing.length > 0) {
+        const readAt = Date.now();
+        const identity = reader.hostIdentity();
+        current.identity = identity;
+        const reusable = previous?.identity === identity ? previous.entries : undefined;
+        const known = [];
+        const refresh = [];
+        let first = Infinity;
+        let last = -Infinity;
+        for (const id of missing) {
+          const entry = reusable?.get(id);
+          if (entry && isSettled(entry, readAt)) {
+            known.push(id);
+            first = Math.min(first, entry.version.seq);
+            last = Math.max(last, entry.version.seq);
+          } else
+            refresh.push(id);
+        }
+        const versions = reader.messageTimeVersions(sessionID, known, { first, last });
+        for (const id of known) {
+          const version = versions.get(id);
+          const cached = reusable?.get(id);
+          if (!version) {
+            passTimes.set(id, null);
+          } else if (cached && sameVersion(cached.version, version) && (version.type === "user" || cached.time.completed !== undefined)) {
+            current.entries.set(id, cached);
+            passTimes.set(id, cached.time);
+          } else
+            refresh.push(id);
+        }
+        const times = reader.messageTimes(sessionID, refresh, versions);
+        for (const id of refresh) {
+          const time = times.get(id);
+          const version = versions.get(id);
+          passTimes.set(id, time ?? null);
+          if (time && version) {
+            const entry = { version, time };
+            if (isSettled(entry, readAt))
+              current.entries.set(id, entry);
+          }
+        }
+      }
+      const result = new Map;
+      for (const id of ids) {
+        const time = passTimes.get(id);
+        if (time)
+          result.set(id, { ...time });
+      }
+      return result;
+    };
+  }
+}
+
 // src/v2/hooks/channel2.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 var pendingCandidates = new WeakMap;
@@ -22038,26 +22908,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 +22981,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 +23026,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;
@@ -22701,7 +23621,7 @@ function projectRawMessages(rows, ordinalFor) {
     const message = {
       id: row.id,
       ordinal: ordinalFor(row, index),
-      role: row.type === "assistant" ? "assistant" : "user",
+      role: row.type === "assistant" ? "assistant" : row.type === "system" ? "system" : "user",
       createdAt: row.time_created ?? row.data.time?.created,
       parts: row.type === "assistant" ? (row.data.content ?? []).map((part) => {
         if (part.type !== "tool")
@@ -22785,6 +23705,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 {
@@ -23616,10 +24552,10 @@ function updateMemoryContentInCurrentTransaction(db, memory, content, normalized
   clearMemoryVerifications(db, memory.id);
 }
 var ctxMemoryArgsShape = {
-  action: tool2.schema.enum([...CTX_MEMORY_ACTIONS]).optional().describe("write | update | archive | merge | get"),
-  content: tool2.schema.string().optional().describe("The memory text — one standalone fact (write, update, merge)."),
-  category: tool2.schema.enum([...V2_MEMORY_CATEGORIES]).optional().describe("Kind of fact (required for write; on update/merge optional, omitted keeps the current category)."),
-  ids: tool2.schema.array(tool2.schema.number()).optional().describe("Memory ids from <project-memory>: one for update, one or more for archive, two or more for merge, 1–20 for get."),
+  action: tool2.schema.enum([...CTX_MEMORY_ACTIONS]).describe("write | update | archive | merge | get"),
+  content: tool2.schema.string().describe("The memory text — one standalone fact (write, update, merge)."),
+  category: tool2.schema.enum([...V2_MEMORY_CATEGORIES]).describe("Kind of fact (required for write; on update/merge, pass the memory's current category to keep it)."),
+  ids: tool2.schema.array(tool2.schema.number()).describe("Memory ids from <project-memory>: one for update, one or more for archive, two or more for merge, 1–20 for get."),
   reason: tool2.schema.string().optional().describe("Why it is being archived (optional).")
 };
 var ctxMemoryArgsSchema = tool2.schema.object({ ...ctxMemoryArgsShape }).passthrough();
@@ -23977,7 +24913,7 @@ function renderGlance(notes, options) {
   const remaining = ordered.length - options.offset - page.length;
   const footer = remaining > 0 ? `
 
-Showing ${page.length} of ${ordered.length} — ${remaining} older: mmc_note(action="read", offset=${options.offset + page.length})` : "";
+Showing ${page.length} of ${ordered.length} — ${remaining} older: mmc_note(action="read", content="", note_ids=[], offset=${options.offset + page.length})` : "";
   return `## Notes
 
 ${rows}${footer}`;
@@ -24015,7 +24951,7 @@ function captureAnchorOrdinal(db, sessionId) {
 }
 var DISMISS_FOOTER = `
 
-To dismiss a stale note: mmc_note(action="dismiss", note_ids=[N])`;
+To dismiss a stale note: mmc_note(action="dismiss", note_ids=[N], content="")`;
 var DEFAULT_READ_LIMIT = 25;
 function readGlanceNotes(args) {
   if (args.filter === undefined) {
@@ -24045,12 +24981,12 @@ function noteAuthorityRefusal(action) {
   return renderCapabilityRefusal(isMutation ? "note_change" : "note_access");
 }
 var ctxNoteArgsShape = {
-  action: tool3.schema.enum(["write", "read", "dismiss", "update"]).optional().describe("write | read | update | dismiss. Defaults to write when content is given, else read."),
-  content: tool3.schema.string().optional().describe("Note text for write/update: first line is the title (under 80 chars), then the detail."),
+  action: tool3.schema.enum(["write", "read", "dismiss", "update"]).describe("write | read | update | dismiss."),
+  content: tool3.schema.string().describe("Note text for write/update: first line is the title (under 80 chars), then the detail."),
   filter: tool3.schema.enum(["all", "active", "dismissed"]).optional().describe("Read filter: active (default), all, dismissed."),
   limit: tool3.schema.number().optional().describe("Rows per read (default 25)."),
   offset: tool3.schema.number().optional().describe("Skip this many newest rows (default 0)."),
-  note_ids: tool3.schema.array(tool3.schema.number().int().min(1)).min(1).max(50).optional().describe("Note ids: one for update, 1–50 for dismiss or read (read returns full bodies). Ignored by write.")
+  note_ids: tool3.schema.array(tool3.schema.number().int().min(1)).max(50).describe("Note ids: one for update, 1–50 for dismiss, or 1–50 to read those notes in full. Write and a plain read take an empty list.")
 };
 var ctxNoteArgsSchema = tool3.schema.object(ctxNoteArgsShape).passthrough();
 function formatDismissResults(results) {
@@ -24089,7 +25025,8 @@ function createCtxNoteTool(deps) {
       });
       const sessionId = toolContext.sessionID;
       const action = args.action ?? (args.content?.trim() ? "write" : "read");
-      const noteIds = action === "dismiss" || action === "update" || action === "read" && args.note_ids !== undefined ? parseNoteIds(action, args.note_ids) : undefined;
+      const targetedReadIds = action === "read" && Array.isArray(args.note_ids) && args.note_ids.length === 0 ? undefined : args.note_ids;
+      const noteIds = action === "dismiss" || action === "update" || action === "read" && targetedReadIds !== undefined ? parseNoteIds(action, targetedReadIds) : undefined;
       if (typeof noteIds === "string")
         return noteIds;
       const projectIdentity = deps.resolveProjectPath?.(toolContext.directory);
@@ -24252,7 +25189,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 +25571,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;
 
@@ -24811,16 +25768,23 @@ function applyV2PromptSurfaceTools(draft, runtime, config) {
 function recordV2ToolDefinitions(draft) {
   if (!draft.tools)
     return;
+  const tools = [];
   for (const [id, tool] of Object.entries(draft.tools)) {
     if (!tool)
       continue;
     recordToolParameters(id, tool.input);
-    recordToolDefinition(draft.model.providerID, draft.model.id, draft.agent, id, typeof tool.description === "string" ? tool.description : "", tool.input);
+    tools.push({
+      id,
+      description: typeof tool.description === "string" ? tool.description : "",
+      parameters: tool.input
+    });
   }
+  recordToolDefinitionSet(draft.model.providerID, draft.model.id, draft.agent, tools, draft.sessionID);
 }
 async function registerContext(context) {
   const directory = context.location.directory;
   const config = loadPluginConfigDetailed(directory).config;
+  log(`[magic-context] OpenCode 2 keep_subagents=${config.keep_subagents === true}`);
   setHomeProjectPermission(config.allow_home_project);
   if (!config.enabled)
     return;
@@ -24857,11 +25821,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",
@@ -24941,6 +25906,7 @@ async function registerContext(context) {
   };
   let hiddenAgentsReady;
   const readerPool = new V2StoreReaderPool;
+  const messageTimesCache = new V2MessageTimesCache;
   const openStoreReader = () => readerPool.open(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
   const createHiddenExecutor = async (database) => {
     await cleanupLegacyOnce(database);
@@ -25184,88 +26150,129 @@ 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);
+              messageTimesCache.delete(sessionID);
+            }
+            if (event.type === "session.step.started" || event.type === "session.step.ended" || event.type === "session.step.failed") {
+              const messageID = event.data.assistantMessageID;
+              if (typeof messageID === "string")
+                messageTimesCache.deleteMessage(sessionID, messageID);
+            }
+            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);
+              messageTimesCache.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) => {
@@ -25281,7 +26288,7 @@ async function registerContext(context) {
       memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
       hardSignals: {
         systemHash: foldDigest(JSON.stringify(draft.system)),
-        toolSetHash: getCurrentToolSetHash(draft.model.providerID, draft.model.id, draft.agent),
+        toolSetHash: getCurrentToolSetHash(draft.model.providerID, draft.model.id, draft.agent, draft.sessionID),
         modelKey: `${draft.model.providerID}/${draft.model.id}`,
         cacheExpired: false,
         lastResponseTime: state.lastResponseTime
@@ -25338,20 +26345,116 @@ 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 initializeTransform = (database) => transform ??= createTransform({
+    cacheTtlConfig: config.cache_ttl,
+    cacheTtlConfigured: config.cacheTtlConfigured,
+    sampleCacheTtlConfig: () => liveConfigReader.poll().effective,
+    db: database,
+    tagger,
+    ...createV2ThresholdDeps(config),
+    contextUsageMap: usage,
+    compactionOff,
+    storeGeneration: "v2",
+    normalizeRestoredAssistantText: (text, providerID) => {
+      const normalized = stripCopiedTagNotation(text);
+      return normalized === "" && !modelAcceptsEmptyContent(providerID) ? text : normalized;
+    },
+    refreshSourceContents: (sessionID) => committedSourceRefreshes.has(sessionID),
+    hostCleanupCompactionMarkers: () => ({
+      verified: true,
+      removedLineages: 0,
+      removedRows: 0,
+      retainedLineages: 0
+    }),
+    protectedTokens: config.protected_tokens,
+    protectedTokenTierOverrides: getProtectedTokensTierOverrides(config),
+    protectedTools: config.protected_tools,
+    liveModelBySession: liveModels,
+    getToolSetHash: (sessionId) => {
+      const model = liveModels.get(sessionId);
+      if (!model)
+        return "";
+      return getCurrentToolSetHash(model.providerID, model.modelID, agents.get(sessionId), sessionId);
+    },
+    channel1StateBySession: channel1,
+    historyRefreshSessions,
+    pendingMaterializationSessions,
+    lastHeuristicsTurnId,
+    variantBySession: variants,
+    keepReasoningTokens: config.keep_reasoning_tokens,
+    directory,
+    sessionDirectoryBySession: sessionDirectories,
+    projectPath: directory,
+    agentBySession: agents,
+    maintenanceConfig: config.maintenance ? () => inheritMaintenanceModelConfig(config) : undefined,
+    hiddenCompletionExecutor,
+    historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
+    historianModel: historianModels.primary,
+    fallbackModels: historianModels.fallbacks,
+    resolveHistorianRun: sampleHistorian,
+    historianTimeoutMs: config.historian_timeout_ms,
+    historianMaxOutputTokens: config.historian?.maxTokens,
+    historianTwoPass: config.historian?.two_pass,
+    historianExpandTools: config.historian?.expand_tools,
+    compactionMarkerStrategy: v2CompactionMarkerStrategy,
+    memoryConfig: {
+      enabled: config.memory.enabled,
+      injectionBudgetTokens: config.memory.injection_budget_tokens,
+      autoPromote: config.memory.auto_promote
+    },
+    ...createHostSeams(context, readAllForConversion, pagedRead, liveModels)
+  });
   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 +26463,11 @@ async function registerContext(context) {
       return;
     }
     await dropStorageNotices(draft.messages, isMagicContextSynthetic);
+    let hostMessagesAtEntry = [...draft.messages];
+    const cachedTimes = messageTimesCache.pass(draft.sessionID);
+    const readTimes = (reader, messages) => {
+      return cachedTimes(reader, timeIds(messages));
+    };
     liveModels.set(draft.sessionID, {
       providerID: draft.model.providerID,
       modelID: draft.model.id
@@ -25371,8 +26479,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 +26516,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 +26605,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 +26622,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);
@@ -25545,63 +26717,15 @@ async function registerContext(context) {
           }
         });
       }
-      transform ??= createTransform({
-        cacheTtlConfig: config.cache_ttl,
-        cacheTtlConfigured: config.cacheTtlConfigured,
-        sampleCacheTtlConfig: () => liveConfigReader.poll().effective,
-        db,
-        tagger,
-        ...createV2ThresholdDeps(config),
-        contextUsageMap: usage,
-        compactionOff,
-        storeGeneration: "v2",
-        normalizeRestoredAssistantText: stripCopiedTagNotation,
-        hostCleanupCompactionMarkers: () => ({
-          verified: true,
-          removedLineages: 0,
-          removedRows: 0,
-          retainedLineages: 0
-        }),
-        protectedTokens: config.protected_tokens,
-        protectedTokenTierOverrides: getProtectedTokensTierOverrides(config),
-        protectedTools: config.protected_tools,
-        liveModelBySession: liveModels,
-        getToolSetHash: (sessionId) => {
-          const model = liveModels.get(sessionId);
-          if (!model)
-            return "";
-          return getCurrentToolSetHash(model.providerID, model.modelID, agents.get(sessionId));
-        },
-        channel1StateBySession: channel1,
-        historyRefreshSessions,
-        pendingMaterializationSessions,
-        lastHeuristicsTurnId,
-        variantBySession: variants,
-        keepReasoningTokens: config.keep_reasoning_tokens,
-        directory,
-        sessionDirectoryBySession: sessionDirectories,
-        projectPath: directory,
-        agentBySession: agents,
-        maintenanceConfig: config.maintenance ? () => inheritMaintenanceModelConfig(config) : undefined,
-        hiddenCompletionExecutor,
-        historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
-        historianModel: historianModels.primary,
-        fallbackModels: historianModels.fallbacks,
-        resolveHistorianRun: sampleHistorian,
-        historianTimeoutMs: config.historian_timeout_ms,
-        historianMaxOutputTokens: config.historian?.maxTokens,
-        historianTwoPass: config.historian?.two_pass,
-        historianExpandTools: config.historian?.expand_tools,
-        compactionMarkerStrategy: v2CompactionMarkerStrategy,
-        memoryConfig: {
-          enabled: config.memory.enabled,
-          injectionBudgetTokens: config.memory.injection_budget_tokens,
-          autoPromote: config.memory.auto_promote
-        },
-        ...createHostSeams(context, readAllForConversion, pagedRead, liveModels)
-      });
+      transform = initializeTransform(db);
+      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 +26740,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 +26756,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 +26767,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 +26805,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 +26827,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 +26853,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 +26870,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 +27016,15 @@ ${baseline}
   }, 0);
   return {
     async dispose() {
+      messageTimesCache.clear();
+      usageController.abort();
       await hiddenCompletionExecutor?.dispose();
+      await usageDone;
       rpcStopped = true;
       rpcServer.stop();
       tools?.dispose();
-      usageController.abort();
-      await usageDone;
       deletedSessions.clear();
+      committedSourceRefreshes.clear();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();