@retaw106/mmc-oc 2.2.1 → 2.3.0

package/dist/{context-mrvm92n8.js → context-wt7g4f8k.js}

@@ -58,11 +58,23 @@ import {
   searchMemoriesFTSUnion,
   clearMemoryVerifications,
   queueMemoryMutation,
+  scheduleAfterBootQuiet,
+  BoundedSessionMap,
   registerOwnRpcServerInstance,
   rpcPortDir,
   rpcPortFilePath,
   parseRpcPortFile,
   inspectProcessesAsync,
+  dirtyLkgRecoveryRevision,
+  ownsLkgDirtyFence,
+  invalidateCleanLkgRecoveryFence,
+  getLastIndexedOrdinal,
+  getIndexedMessageIdAtOrdinal,
+  getIndexedMessageCorpusSize,
+  getMessageIndexReconciliationStartOrdinal,
+  isMessageIndexReconciledThrough,
+  clearIndexedMessages,
+  indexMessagesAfterOrdinal,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -74,15 +86,6 @@ import {
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
   getAuthorityManagedMarker,
-  getLastIndexedOrdinal,
-  getIndexedMessageIdAtOrdinal,
-  getIndexedMessageCorpusSize,
-  getMessageIndexReconciliationStartOrdinal,
-  isMessageIndexReconciledThrough,
-  clearIndexedMessages,
-  indexMessagesAfterOrdinal,
-  layoutLkgPrefix,
-  assembleLkgPrefix,
   getTemporalDecisions,
   observeTemporalDecisions,
   freezeTemporalDecisions,
@@ -123,7 +126,7 @@ import {
   casChannel2NudgeClaim,
   getAutoSearchHintDecisions,
   appendAutoSearchHintDecision,
-  pruneAutoSearchHintDecisions,
+  flushAutoSearchHintDecisionRetirement,
   getPersistedTodoPermissionDenied,
   setPersistedTodoPermissionDenied,
   getPersistedTodoSyntheticAnchor,
@@ -152,32 +155,66 @@ import {
   addTrailingBlankDecisions,
   demoteTrailingBlankKeepDecisions,
   addStaleReduceStrippedIds,
+  getProcessedImageMarkers,
   addProcessedImageStrippedIds,
   getPendingCompactionMarkerState,
   getCompactionMarkerHealth,
   loadPostprocessReplaySnapshot,
   clearPendingCompactionMarkerStateIf,
+  getPendingPiCompactionMarkerState,
+  clearPendingPiCompactionMarkerStateIf,
+  logPiCompactionMarkerClear,
   setSessionWorkMetrics,
   getObservedEpochFloor,
   resolveEpochFloorForPass,
-  BoundedSessionMap,
+  providerResponseFailed,
+  isSuccessfulProviderCompletion,
+  rememberUnpublishedAutoSearchNoHint,
+  getUnpublishedAutoSearchNoHint,
+  forgetUnpublishedAutoSearchNoHint,
+  registerAutoSearchWork,
+  gaDatabasePath,
+  RAW_MESSAGE_TYPES,
+  V2StoreReaderPool,
+  getOrCreateSessionMeta,
+  updateSessionMeta,
+  advanceToolReclaimWatermark,
+  markSessionCleanupPending,
+  clearSession,
+  requestPendingMaterialization,
+  pendingMaterializationOrigin,
+  clearPendingMaterialization,
+  recordSystemPromptForRequest,
+  recordHeldHeadForRequest,
+  bindSystemPromptResponse,
+  isHeldHeadForRequest,
+  deferDeliveredSystemRefresh,
+  retirePendingSystemPromptDelivery,
+  lkgProviderInputTotal,
+  beginV2LkgRequest,
+  currentLkgRequestIdentity,
+  noteLkgProviderResponse,
+  clearLkgMeasuredRequest,
+  saveLkgSlotToDb,
+  loadPersistedLkgSlot,
+  pruneStaleLkgSlots,
+  resolveLkgModelKeys,
+  createLkgEntryProjector,
+  captureLkgSlot,
+  replayLkg,
+  noteUncertifiedNormalLkg,
+  lkgDirtyRevision,
+  readLkgRecoveryPrefix,
+  noteLkgHealthyPrefix,
   beginLkgPass,
-  lkgContentFields,
-  lkgContentDigestFromFields,
-  memoizedLkgContentDigestFromFields,
-  exactReusablePrefix,
-  lkgContentDigest,
-  captureSlot,
   getInMemorySlot,
   getSlot,
   dropSlot,
-  noteEntry,
   getLkgSlotHeapStats,
   TOOL_SWEEP_SCOPED_MARKER,
   useScopedToolSweep,
   createPreAdoptionToolSweepResolver,
   copySessionStateForClone,
-  scheduleAfterBootQuiet,
   getSchemaFenceRejection,
   getMigrationOnOpenRefusal,
   LATEST_SUPPORTED_VERSION,
@@ -186,14 +223,6 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError,
-  gaDatabasePath,
-  RAW_MESSAGE_TYPES,
-  V2StoreReaderPool,
-  getOrCreateSessionMeta,
-  updateSessionMeta,
-  advanceToolReclaimWatermark,
-  markSessionCleanupPending,
-  clearSession,
   getNoteByIdInScope,
   getNotes,
   addNote,
@@ -265,7 +294,7 @@ import {
   recordHighPressureNoEligibleHead,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-5b7x80ec.js";
+} from "./index-kw21z5pe.js";
 import {
   getHarness,
   getDataDir,
@@ -273,14 +302,13 @@ import {
   log,
   sessionLog,
   getLoggerDiagnostics
-} from "./index-qbkzdkk0.js";
+} from "./index-k59af64t.js";
 import {
   shouldEnforcePrivateStoragePermissions,
   ensureStorageDirectorySync,
   writeStorageFileAtomicSync,
   writeStorageFileAsync,
   createStorageWriteStream,
-  setWindowOverlayPath,
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
   isSaneLimit,
@@ -294,14 +322,11 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-5cep2r9n.js";
+} from "./index-5ty9rnbx.js";
 import {
   normalizeProtectedToolName,
   mergeProtectedTools,
   isRecord,
-  detectLatestTurnThinkingMismatch,
-  isPrefixBoundThinkingModel,
-  detectOverflow,
   protectedToolTagNumbers,
   protectedToolTokenCount,
   textMentionsRecentCommit,
@@ -311,6 +336,7 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   stripWellFormedLeadingTagPrefix,
+  stripPersistedAssistantText,
   byteSize,
   stripTagPrefix,
   peelLeadingMcTagNotation,
@@ -348,6 +374,7 @@ import {
   getPendingOpsCount,
   clearPendingOps,
   removePendingOp,
+  tagIdentityRevisionKey,
   getRecentTagOwnerMessageIds,
   AGE_RECLAIM_MIN_TOKENS,
   getOldestActiveUnprotectedToolTags,
@@ -355,12 +382,17 @@ import {
   getTriggerTagTokenUpperBound,
   getActiveTagTokenTotalsByMessage,
   getReasoningTokenEstimatesByMessage,
+  tryGetReasoningTokenEstimatesByMessage,
+  getMaxTagNumberByOwnerMessage,
+  scanTagOwnerSummary,
+  isTagOwnerSummaryReady,
   tagTokenCountIsNull,
   backfillTagTokenCounts,
   insertTag,
   updateTagStatus,
   markWhitespaceAssistantTagInert,
   getInertWhitespaceAssistantTags,
+  getInertWhitespaceAssistantTagsByNumbers,
   updateTagDropMode,
   updateCavemanDepth,
   updateTagMessageId,
@@ -384,8 +416,6 @@ import {
   pickNearestPriorOwner,
   expandToolPart,
   markHostUnservedRow,
-  extractInMemoryMessageViews,
-  buildInMemoryTailRawMessages,
   estimateTrueRawMessageTokens,
   stripSystemInjection,
   isTextPart,
@@ -405,6 +435,9 @@ import {
   wireContentBytes,
   createFinalWireUsageTracker,
   estimateFinalWireInputTokens,
+  detectLatestTurnThinkingMismatch,
+  isPrefixBoundThinkingModel,
+  detectOverflow,
   modelAcceptsEmptyContent,
   isAnthropicFamilyRoute,
   neutralizeDroppedReasoningPart,
@@ -414,6 +447,7 @@ import {
   variantChangeBustsProviderCache,
   makeSentinel,
   makeWholeMessageSentinel,
+  neutralizeWholeMessage,
   isSentinel,
   replaySentinelByMessageIds,
   SKELETON_REAL_INPUT_MAX_BYTES,
@@ -425,11 +459,13 @@ import {
   withRawSessionMessageCache2,
   readRawSessionMessages2,
   visitRawSessionMessages2,
+  prepareRawSessionOrdinals2,
   primeTailRawMessageCache2,
   primeInMemoryTailRawMessageCache2,
+  readRawSessionMessageIdOrdinalsForRange2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-btp5tdc8.js";
+} from "./index-z2w1eq3y.js";
 import {
   getSqliteMemoryStats,
   withSqliteBackgroundWriter,
@@ -437,8 +473,10 @@ import {
   withoutSqliteTransformPass,
   isTransientSqliteError,
   SqliteAcquisitionBusyError,
-  withAsyncPrivilegedWriter
-} from "./index-1j34a56j.js";
+  withAsyncPrivilegedWriter,
+  indexCoordinationInput,
+  withIndexChunk
+} from "./index-czba8tw3.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -448,11 +486,14 @@ import {
   resolveDecisionCalibration
 } from "./index-x37vg474.js";
 import {
+  extractInMemoryMessageViews,
+  buildInMemoryTailRawMessages,
   openCodeDbExists,
   withReadOnlySessionDb,
+  latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-ramz5kkm.js";
+} from "./index-18yrysyj.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -460,18 +501,18 @@ import {
   drainNotifications2,
   isTuiConnected2
 } from "./index-jdxxq8cz.js";
-import"./index-53g38ggt.js";
+import"./index-kmbme1v1.js";
 import {
   getErrorMessage,
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./index-amycb7b1.js";
+} from "./index-a5mw0xp3.js";
 import {
   resolveHistorianModel2
 } from "./index-z2g20msd.js";
 import {
   logSlowWriteTransaction
-} from "./index-33gprt9g.js";
+} from "./index-yjv8dpht.js";
 
 // src/config/index.ts
 import { existsSync as existsSync4 } from "node:fs";
@@ -1578,6 +1619,15 @@ function migrateLegacyAgentEnabledInMemory(rawConfig, warnings) {
   return patched;
 }
 
+// src/config/deprecated-config.ts
+var WINDOW_OVERLAY_PATH_DEPRECATION_WARNING = "models.window_overlay_path is deprecated and ignored; Fusiform no longer publishes window-overlay data, so this setting no longer changes model window geometry. Remove this key.";
+function warnDeprecatedWindowOverlayPath(config, warnings) {
+  const models = config.models;
+  if (typeof models === "object" && models !== null && Object.hasOwn(models, "window_overlay_path") && !warnings.includes(WINDOW_OVERLAY_PATH_DEPRECATION_WARNING)) {
+    warnings.push(WINDOW_OVERLAY_PATH_DEPRECATION_WARNING);
+  }
+}
+
 // src/config/legacy-harness-blocks.ts
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1915,7 +1965,7 @@ function stripUnsafeProjectConfigFields(projectRaw) {
   const models = projectRaw.models;
   if (isPlainObject2(models) && "window_overlay_path" in models) {
     delete models.window_overlay_path;
-    warnings.push("Ignoring models.window_overlay_path from project config (security: only user-level config may select model geometry metadata).");
+    warnings.push("Ignoring models.window_overlay_path from project config (deprecated; this setting no longer changes model window geometry).");
   }
   if ("language" in projectRaw) {
     delete projectRaw.language;
@@ -2633,6 +2683,7 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
   const configWithoutRemovedAgent = stripRemovedAgentConfig(rawConfig, preMigrationWarnings);
   const migratedExperimental = migrateLegacyExperimental(configWithoutRemovedAgent, preMigrationWarnings);
   const migrated = migrateLegacyAgentEnabledInMemory(migratedExperimental, preMigrationWarnings);
+  warnDeprecatedWindowOverlayPath(migrated, preMigrationWarnings);
   const parsed = MagicContextConfigSchema.safeParse(migrated);
   const disabledHooks = Array.isArray(rawConfig.disabled_hooks) ? rawConfig.disabled_hooks.filter((value) => typeof value === "string") : undefined;
   const command = typeof rawConfig.command === "object" && rawConfig.command !== null ? rawConfig.command : undefined;
@@ -2851,7 +2902,6 @@ function loadPluginConfigDetailed(directory, applyRuntimeGlobals = true) {
     config.profile = profileResolution.activeProfile;
   if (applyRuntimeGlobals) {
     setOutputReserveConfig(config.output_reserve);
-    setWindowOverlayPath(config.models?.window_overlay_path);
   }
   const leafValidationWarnings = [...config.configWarnings ?? []];
   if (config.configWarnings?.length) {
@@ -4876,6 +4926,236 @@ function createOc2MaintenanceRunFactory(options) {
   };
 }
 
+// src/features/magic-context/message-index-async.ts
+function isDatabaseLockedError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const e = error;
+  if (typeof e.code === "string") {
+    if (e.code === "SQLITE_BUSY" || e.code === "SQLITE_LOCKED")
+      return true;
+  }
+  if (typeof e.message === "string") {
+    if (/database is locked/i.test(e.message))
+      return true;
+    if (/sqlite_(busy|locked)/i.test(e.message))
+      return true;
+  }
+  return false;
+}
+var RECONCILIATION_BATCH_SIZE = 100;
+
+class MagicContextMessageIndexHeapHolder {
+  reconciledSessions = new Set;
+  reconciliationScheduledSessions = new Set;
+  clearAndReindexScheduledSessions = new Map;
+  sessionLocks = new Map;
+  incrementalTimers = new Map;
+  pendingIncrementalKeys = new Set;
+  completedIncrementalKeys = new Set;
+  activeReconcilerBuffers = new Map;
+}
+var heapHolder = new MagicContextMessageIndexHeapHolder;
+function clearCompletedIncrementalKeys(sessionId) {
+  const prefix = `${sessionId}\x00`;
+  for (const key of heapHolder.completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      heapHolder.completedIncrementalKeys.delete(key);
+  }
+}
+var sessionEpochs = new Map;
+var PREPARE_RETRY_MS = 60000;
+async function sourceReady(source, sessionId) {
+  const prepare = source?.prepare;
+  return typeof prepare === "function" ? prepare(sessionId) : true;
+}
+function defer(fn) {
+  const immediate = globalThis.setImmediate;
+  if (typeof immediate === "function") {
+    immediate(fn);
+    return;
+  }
+  setTimeout(fn, 0);
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => defer(resolve));
+}
+function runWithSessionLock(sessionId, operation) {
+  const previous = heapHolder.sessionLocks.get(sessionId) ?? Promise.resolve();
+  const run = previous.catch(() => {
+    return;
+  }).then(async () => {
+    await operation();
+  });
+  heapHolder.sessionLocks.set(sessionId, run);
+  run.finally(() => {
+    if (heapHolder.sessionLocks.get(sessionId) === run) {
+      heapHolder.sessionLocks.delete(sessionId);
+    }
+  }).catch(() => {
+    return;
+  });
+  return run;
+}
+function logIndexingError(sessionId, action, error) {
+  if (isDatabaseLockedError(error)) {
+    sessionLog(sessionId, `message FTS async ${action} skipped (database busy; will retry on next reconciliation)`);
+    return;
+  }
+  sessionLog(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
+  log(`[message-index-async] ${action} failed for ${sessionId}:`, error);
+}
+function serializedMessageBytes(messages) {
+  try {
+    return Buffer.byteLength(JSON.stringify(messages));
+  } catch {
+    return 0;
+  }
+}
+function detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMessages, fallbackSnapshot) {
+  if (finalWatermark <= 0)
+    return null;
+  const indexedWatermark = getLastIndexedOrdinal(db, sessionId);
+  if (indexedWatermark > finalWatermark) {
+    return `indexed watermark ${indexedWatermark} exceeds projection watermark ${finalWatermark}`;
+  }
+  if (cursor <= 0 || cursor > finalWatermark)
+    return null;
+  const indexedId = getIndexedMessageIdAtOrdinal(db, sessionId, cursor);
+  if (indexedId === null)
+    return null;
+  const projectedId = readMessages.readPage ? readMessages.readPage(sessionId, cursor - 1, 1, finalWatermark)[0]?.id ?? null : fallbackSnapshot?.find((message) => message.ordinal === cursor)?.id ?? null;
+  if (projectedId === null || projectedId === indexedId)
+    return null;
+  return `indexed id '${indexedId}' at ordinal ${cursor} but projection has '${projectedId}'`;
+}
+async function reconcileSessionIndex(db, sessionId, readMessages) {
+  if (!await sourceReady(readMessages, sessionId))
+    return false;
+  await runWithSessionLock(sessionId, async () => {
+    if (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;
+      let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+      let after;
+      const misalignment = 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);
+      }
+      while (cursor < finalWatermark) {
+        const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
+        const messages = readMessages.readPage ? readMessages.readPage(sessionId, cursor, RECONCILIATION_BATCH_SIZE, finalWatermark, after) : (fallbackSnapshot ?? []).filter((message) => message.ordinal > cursor && message.ordinal <= pageEnd);
+        const retainedMessages = fallbackSnapshot ?? messages;
+        heapHolder.activeReconcilerBuffers.set(sessionId, retainedMessages);
+        await withIndexChunk(indexCoordinationInput(), () => withSqliteBackgroundWriter(() => indexMessagesAfterOrdinal(db, sessionId, messages, cursor, pageEnd)));
+        const nextCursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+        if (nextCursor <= cursor)
+          break;
+        cursor = nextCursor;
+        const last = messages.at(-1);
+        after = last?.ordinal === cursor && typeof last.createdAt === "number" ? { timeCreated: last.createdAt, id: last.id } : undefined;
+        if (cursor < finalWatermark) {
+          await yieldToEventLoop();
+        }
+      }
+      if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
+        heapHolder.reconciledSessions.add(sessionId);
+      }
+    } finally {
+      heapHolder.activeReconcilerBuffers.delete(sessionId);
+    }
+  });
+  return true;
+}
+function scheduleReconciliation(db, sessionId, readMessages) {
+  if (heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
+    return;
+  }
+  heapHolder.reconciliationScheduledSessions.add(sessionId);
+  scheduleAfterBootQuiet(() => {
+    defer(() => {
+      reconcileSessionIndex(db, sessionId, readMessages).then((ran) => {
+        if (ran)
+          return;
+        setTimeout(() => {
+          heapHolder.reconciliationScheduledSessions.delete(sessionId);
+          scheduleReconciliation(db, sessionId, readMessages);
+        }, PREPARE_RETRY_MS).unref?.();
+      }).catch((error) => {
+        logIndexingError(sessionId, "reconciliation", error);
+        if (isDatabaseLockedError(error))
+          setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000).unref();
+      }).finally(() => {
+        heapHolder.reconciliationScheduledSessions.delete(sessionId);
+      });
+    });
+  });
+}
+function scheduleReconciliationCatchup(db, sessionId, readMessages) {
+  if (typeof readMessages.getCount !== "function") {
+    scheduleReconciliation(db, sessionId, readMessages);
+    return;
+  }
+  let count;
+  try {
+    count = readMessages.getCount(sessionId);
+  } catch {
+    return;
+  }
+  if (count <= getLastIndexedOrdinal(db, sessionId))
+    return;
+  heapHolder.reconciledSessions.delete(sessionId);
+  scheduleReconciliation(db, sessionId, readMessages);
+}
+function scheduleClearAndReindex(db, sessionId, readMessages) {
+  heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciliationScheduledSessions.delete(sessionId);
+  clearCompletedIncrementalKeys(sessionId);
+  const existing = heapHolder.clearAndReindexScheduledSessions.get(sessionId);
+  if (existing) {
+    existing.source = readMessages;
+    return;
+  }
+  const pending = { source: readMessages };
+  heapHolder.clearAndReindexScheduledSessions.set(sessionId, pending);
+  scheduleAfterBootQuiet(() => {
+    defer(() => {
+      let cleared = false;
+      runWithSessionLock(sessionId, () => {
+        if (heapHolder.clearAndReindexScheduledSessions.get(sessionId) !== pending)
+          return;
+        heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
+        heapHolder.reconciledSessions.delete(sessionId);
+        clearCompletedIncrementalKeys(sessionId);
+        clearIndexedMessages(db, sessionId);
+        cleared = true;
+      }).then(() => cleared ? reconcileSessionIndex(db, sessionId, pending.source) : undefined).catch((error) => {
+        heapHolder.reconciledSessions.delete(sessionId);
+        if (heapHolder.clearAndReindexScheduledSessions.get(sessionId) === pending)
+          heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
+        logIndexingError(sessionId, "clear and reindex", error);
+      });
+    });
+  });
+}
+function getMessageIndexQueueHeapStats() {
+  return {
+    queueLength: heapHolder.reconciliationScheduledSessions.size + heapHolder.incrementalTimers.size + heapHolder.pendingIncrementalKeys.size,
+    reconciliationScheduled: heapHolder.reconciliationScheduledSessions.size,
+    incrementalTimers: heapHolder.incrementalTimers.size,
+    pendingIncremental: heapHolder.pendingIncrementalKeys.size,
+    activeSessionLocks: heapHolder.sessionLocks.size,
+    completedIncrementalKeys: heapHolder.completedIncrementalKeys.size,
+    activeBufferMessages: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + messages.length, 0),
+    activeBufferBytes: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + serializedMessageBytes(messages), 0)
+  };
+}
+
 // src/shared/model-cache-ttl.ts
 var MODEL_CACHE_LIFETIMES = [
   {
@@ -5240,7 +5520,9 @@ function makeToolCompositeKey(ownerMsgId, callId) {
   return `${ownerMsgId}${TOOL_COMPOSITE_KEY_SEP}${callId}`;
 }
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_TAGS_VERSION_SQL = `SELECT tags_version FROM session_meta WHERE session_id = ?`;
+var GET_TAGS_VERSION_SQL = `SELECT
+    (SELECT tags_version FROM session_meta WHERE session_id = ?) AS tags_version,
+    (SELECT value FROM schema_migrations_meta WHERE key = ?) AS identity_revision`;
 var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
 var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
 var probeTagsVersionStatements = new WeakMap;
@@ -5361,10 +5643,16 @@ function createTagger() {
       const memCounter = heapHolder.counters.get(sessionId) ?? 0;
       const dbMax = getMaxTagNumberBySession(db, sessionId);
       const next = Math.max(memCounter, dbMax) + 1;
+      const loaded = heapHolder.loadSignatures.get(sessionId);
+      let ownedInitialIdentity;
       try {
         db.transaction(() => {
+          const admitted = loaded?.db === db && loaded.identityRevision === null ? probeSignature(sessionId, db) : null;
+          const initializesOwnedEpoch = admitted !== null && loaded !== undefined && admitted.identityRevision === null && admitted.tagsVersion === loaded.tagsVersion;
           getUpsertCounterStatement(db).run(sessionId, next, getHarness());
           insertTag(db, sessionId, messageId, type, byteSize, next, reasoningByteSize, toolName, inputByteSize, toolOwnerMessageId, entryFingerprint, tokenCounts);
+          if (initializesOwnedEpoch)
+            ownedInitialIdentity = probeSignature(sessionId, db).identityRevision;
         }).immediate();
       } catch (error) {
         if (!isUniqueConstraintError(error)) {
@@ -5385,6 +5673,8 @@ function createTagger() {
       const signature = heapHolder.loadSignatures.get(sessionId);
       if (signature?.db === db) {
         signature.tagsVersion += 1;
+        if (signature === loaded && ownedInitialIdentity !== undefined)
+          signature.identityRevision = ownedInitialIdentity;
       }
       if (type === "tool") {
         getSessionToolAccounting(sessionId).set(next, {
@@ -5487,15 +5777,16 @@ function createTagger() {
     return heapHolder.counters.get(sessionId) ?? 0;
   }
   function probeSignature(sessionId, db) {
-    const row = getProbeTagsVersionStatement(db).get(sessionId);
+    const row = getProbeTagsVersionStatement(db).get(sessionId, tagIdentityRevisionKey(sessionId));
     return {
-      tagsVersion: row?.tags_version ?? 0
+      tagsVersion: row?.tags_version ?? 0,
+      identityRevision: row?.identity_revision ?? null
     };
   }
   function initFromDb(sessionId, db, floor = 0) {
     const probe = probeSignature(sessionId, db);
     const cached = heapHolder.loadSignatures.get(sessionId);
-    if (cached !== undefined && cached.db === db && cached.tagsVersion === probe.tagsVersion && cached.floor === floor) {
+    if (cached !== undefined && cached.db === db && cached.tagsVersion === probe.tagsVersion && cached.identityRevision === probe.identityRevision && cached.floor === floor) {
       return;
     }
     const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
@@ -5528,6 +5819,7 @@ function createTagger() {
     heapHolder.loadSignatures.set(sessionId, {
       db,
       tagsVersion: probe.tagsVersion,
+      identityRevision: probe.identityRevision,
       floor
     });
   }
@@ -5535,6 +5827,10 @@ function createTagger() {
     const signature = heapHolder.loadSignatures.get(sessionId);
     return signature?.db === db ? signature.tagsVersion : undefined;
   }
+  function getLoadedTagIdentityRevision(sessionId, db) {
+    const signature = heapHolder.loadSignatures.get(sessionId);
+    return signature?.db === db ? signature.identityRevision : undefined;
+  }
   function cleanup(sessionId) {
     heapHolder.counters.delete(sessionId);
     heapHolder.assignments.delete(sessionId);
@@ -5577,6 +5873,7 @@ function createTagger() {
     getCounter,
     initFromDb,
     getLoadedTagsVersion,
+    getLoadedTagIdentityRevision,
     cleanup,
     getHeapStats
   };
@@ -5936,25 +6233,35 @@ function forgetCachedPrefix(sessionId) {
   clearInjectionCache(sessionId);
   resetPrefixTrimFallbackState(sessionId);
 }
-function dropCompartmentsAfter(db, sessionId, anchor, holderId) {
+function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = false, onRetire) {
   db.exec("BEGIN IMMEDIATE");
   let finished = false;
+  let clearedMarker = null;
   try {
     if (!isCompartmentLeaseHeld(db, sessionId, holderId)) {
       db.exec("ROLLBACK");
       finished = true;
       return null;
     }
-    const dropped = db.prepare("SELECT id, sequence FROM compartments WHERE session_id = ? AND sequence > ? ORDER BY sequence").all(sessionId, anchor.sequence);
+    const dropped = db.prepare("SELECT id, sequence FROM compartments WHERE session_id = ? AND sequence > ? ORDER BY sequence").all(sessionId, anchor?.sequence ?? -1);
+    onRetire?.();
     const deleteEmbeddings = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE compartment_id = ?");
     for (const row of dropped)
       deleteEmbeddings.run(row.id);
-    db.prepare("DELETE FROM compartments WHERE session_id = ? AND sequence > ?").run(sessionId, anchor.sequence);
-    db.prepare("DELETE FROM compression_depth WHERE session_id = ? AND message_ordinal > ?").run(sessionId, anchor.endMessage);
+    db.prepare("DELETE FROM compartments WHERE session_id = ? AND sequence > ?").run(sessionId, anchor?.sequence ?? -1);
+    db.prepare("DELETE FROM compression_depth WHERE session_id = ? AND message_ordinal > ?").run(sessionId, anchor?.endMessage ?? 0);
+    if (activeBranch) {
+      db.prepare("UPDATE session_meta SET prior_boundary_ordinal = ? WHERE session_id = ?").run((anchor?.endMessage ?? 0) + 1, sessionId);
+      const marker = getPendingPiCompactionMarkerState(db, sessionId);
+      if (marker && clearPendingPiCompactionMarkerStateIf(db, sessionId, marker, null))
+        clearedMarker = marker;
+    }
     queueM0Mutation(db, { sessionId, mutationType: "recomp_boundary_change" });
     clearCachedM0M1(db, sessionId);
     db.exec("COMMIT");
     finished = true;
+    if (clearedMarker)
+      logPiCompactionMarkerClear(sessionId, clearedMarker, "active-branch-retired");
     return dropped.map((row) => row.sequence);
   } finally {
     if (!finished) {
@@ -5965,24 +6272,38 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId) {
   }
 }
 function repairMissingHistoryBoundary(args) {
-  const { db, sessionId, isInHostStore } = args;
-  const compartments = getCompartments(db, sessionId);
+  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);
   let latestIndex = compartments.length - 1;
   while (latestIndex >= 0 && !compartments[latestIndex]?.endMessageId)
     latestIndex -= 1;
   if (latestIndex < 0)
     return { kind: "intact" };
+  if (scope === "active-branch") {
+    for (let index = 0;index <= latestIndex; index += 1) {
+      const endId = compartments[index]?.endMessageId;
+      if (!endId)
+        continue;
+      const present = isInHostStore(endId);
+      if (present === null)
+        return { kind: "unknown" };
+      if (!present) {
+        latestIndex = index;
+        break;
+      }
+    }
+  }
   const latestEnd = compartments[latestIndex].endMessageId;
   const latestPresent = isInHostStore(latestEnd);
   if (latestPresent === null)
     return { kind: "unknown" };
   if (!latestPresent) {
     const missing = latestEnd;
-    const problem = `newest compartment end ${latestEnd} is not in the host store`;
+    const problem = `compartment end ${latestEnd} is not in ${scope === "active-branch" ? "the active host branch" : "the host store"}`;
     const anchor = findAnchor(compartments, latestIndex, isInHostStore);
     if (anchor === "unknown")
       return { kind: "unknown" };
-    if (anchor === null) {
+    if (anchor === null && scope === "store") {
       sessionLog(sessionId, `history boundary unresolved: ${problem} and no older compartment end is in the host store; nothing to re-anchor on`);
       return { kind: "unresolved", reason: "no-anchor", missingEndMessageId: missing };
     }
@@ -5994,8 +6315,15 @@ function repairMissingHistoryBoundary(args) {
       return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
     }
     let dropped;
+    let anchorForDrop = anchor;
     try {
-      dropped = dropCompartmentsAfter(db, sessionId, anchor, holderId);
+      if (scope === "active-branch" && 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 };
+        anchorForDrop = { ...anchor, endMessage: row.endMessage };
+      }
+      dropped = dropCompartmentsAfter(db, sessionId, anchorForDrop, holderId, scope === "active-branch", () => args.onRetire?.(compartments.slice(latestIndex), anchor));
     } finally {
       releaseCompartmentLeaseBestEffort(db, sessionId, holderId);
     }
@@ -6004,14 +6332,16 @@ function repairMissingHistoryBoundary(args) {
     }
     forgetCachedPrefix(sessionId);
     const range = dropped.length === 0 ? "none" : `${dropped[0]}-${dropped[dropped.length - 1]} (${dropped.length})`;
-    sessionLog(sessionId, `history boundary repair: ${problem}; re-anchored on compartment ${anchor.sequence} ending at ${anchor.endMessageId} (ordinal ${anchor.endMessage}); removed compartments ${range} for the historian to rebuild; the cached prefix is rebuilt on this pass`);
+    sessionLog(sessionId, `history boundary repair: ${problem}; re-anchored on ${anchorForDrop ? `compartment ${anchorForDrop.sequence} ending at ${anchorForDrop.endMessageId} (ordinal ${anchorForDrop.endMessage})` : "the start of history"}; removed compartments ${range} for the historian to rebuild; the cached prefix is rebuilt on this pass`);
     return {
       kind: "repaired",
       missingEndMessageId: missing,
-      anchorEndMessageId: anchor.endMessageId,
+      anchorEndMessageId: anchor?.endMessageId ?? "",
       droppedSequences: dropped
     };
   }
+  if (scope === "active-branch")
+    return { kind: "intact" };
   const baseline = readBaseline(db, sessionId);
   if (!baseline.hasCachedM0 || baseline.boundary === null || baseline.boundary === latestEnd) {
     return { kind: "intact" };
@@ -6028,175 +6358,15 @@ function repairMissingHistoryBoundary(args) {
   };
 }
 
-// src/features/magic-context/message-index-async.ts
-function isDatabaseLockedError(error) {
-  if (!error || typeof error !== "object")
-    return false;
-  const e = error;
-  if (typeof e.code === "string") {
-    if (e.code === "SQLITE_BUSY" || e.code === "SQLITE_LOCKED")
-      return true;
-  }
-  if (typeof e.message === "string") {
-    if (/database is locked/i.test(e.message))
-      return true;
-    if (/sqlite_(busy|locked)/i.test(e.message))
-      return true;
-  }
-  return false;
-}
-var RECONCILIATION_BATCH_SIZE = 100;
-
-class MagicContextMessageIndexHeapHolder {
-  reconciledSessions = new Set;
-  reconciliationScheduledSessions = new Set;
-  clearAndReindexScheduledSessions = new Map;
-  sessionLocks = new Map;
-  incrementalTimers = new Map;
-  pendingIncrementalKeys = new Set;
-  completedIncrementalKeys = new Set;
-  activeReconcilerBuffers = new Map;
-}
-var heapHolder = new MagicContextMessageIndexHeapHolder;
-function defer(fn) {
-  const immediate = globalThis.setImmediate;
-  if (typeof immediate === "function") {
-    immediate(fn);
-    return;
-  }
-  setTimeout(fn, 0);
-}
-function yieldToEventLoop() {
-  return new Promise((resolve) => defer(resolve));
-}
-function runWithSessionLock(sessionId, operation) {
-  const previous = heapHolder.sessionLocks.get(sessionId) ?? Promise.resolve();
-  const run = previous.catch(() => {
-    return;
-  }).then(async () => {
-    await operation();
-  });
-  heapHolder.sessionLocks.set(sessionId, run);
-  run.finally(() => {
-    if (heapHolder.sessionLocks.get(sessionId) === run) {
-      heapHolder.sessionLocks.delete(sessionId);
-    }
-  }).catch(() => {
-    return;
-  });
-  return run;
-}
-function logIndexingError(sessionId, action, error) {
-  if (isDatabaseLockedError(error)) {
-    sessionLog(sessionId, `message FTS async ${action} skipped (database busy; will retry on next reconciliation)`);
-    return;
-  }
-  sessionLog(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
-  log(`[message-index-async] ${action} failed for ${sessionId}:`, error);
-}
-function serializedMessageBytes(messages) {
-  try {
-    return Buffer.byteLength(JSON.stringify(messages));
-  } catch {
-    return 0;
-  }
-}
-function detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMessages, fallbackSnapshot) {
-  if (finalWatermark <= 0)
-    return null;
-  const indexedWatermark = getLastIndexedOrdinal(db, sessionId);
-  if (indexedWatermark > finalWatermark) {
-    return `indexed watermark ${indexedWatermark} exceeds projection watermark ${finalWatermark}`;
-  }
-  if (cursor <= 0 || cursor > finalWatermark)
-    return null;
-  const indexedId = getIndexedMessageIdAtOrdinal(db, sessionId, cursor);
-  if (indexedId === null)
-    return null;
-  const projectedId = readMessages.readPage ? readMessages.readPage(sessionId, cursor - 1, 1, finalWatermark)[0]?.id ?? null : fallbackSnapshot?.find((message) => message.ordinal === cursor)?.id ?? null;
-  if (projectedId === null || projectedId === indexedId)
-    return null;
-  return `indexed id '${indexedId}' at ordinal ${cursor} but projection has '${projectedId}'`;
-}
-async function reconcileSessionIndex(db, sessionId, readMessages) {
-  await runWithSessionLock(sessionId, async () => {
-    if (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;
-      let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
-      let after;
-      const misalignment = 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);
-      }
-      while (cursor < finalWatermark) {
-        const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
-        const messages = readMessages.readPage ? readMessages.readPage(sessionId, cursor, RECONCILIATION_BATCH_SIZE, finalWatermark, after) : (fallbackSnapshot ?? []).filter((message) => message.ordinal > cursor && message.ordinal <= pageEnd);
-        const retainedMessages = fallbackSnapshot ?? messages;
-        heapHolder.activeReconcilerBuffers.set(sessionId, retainedMessages);
-        withSqliteBackgroundWriter(() => indexMessagesAfterOrdinal(db, sessionId, messages, cursor, pageEnd));
-        const nextCursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
-        if (nextCursor <= cursor)
-          break;
-        cursor = nextCursor;
-        const last = messages.at(-1);
-        after = last?.ordinal === cursor && typeof last.createdAt === "number" ? { timeCreated: last.createdAt, id: last.id } : undefined;
-        if (cursor < finalWatermark) {
-          await yieldToEventLoop();
-        }
-      }
-      if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
-        heapHolder.reconciledSessions.add(sessionId);
-      }
-    } finally {
-      heapHolder.activeReconcilerBuffers.delete(sessionId);
-    }
-  });
-}
-function scheduleReconciliation(db, sessionId, readMessages) {
-  if (heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
-    return;
-  }
-  heapHolder.reconciliationScheduledSessions.add(sessionId);
-  scheduleAfterBootQuiet(() => {
-    defer(() => {
-      reconcileSessionIndex(db, sessionId, readMessages).catch((error) => {
-        logIndexingError(sessionId, "reconciliation", error);
-        if (isDatabaseLockedError(error))
-          setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000).unref();
-      }).finally(() => {
-        heapHolder.reconciliationScheduledSessions.delete(sessionId);
-      });
-    });
-  });
-}
-function getMessageIndexQueueHeapStats() {
-  return {
-    queueLength: heapHolder.reconciliationScheduledSessions.size + heapHolder.incrementalTimers.size + heapHolder.pendingIncrementalKeys.size,
-    reconciliationScheduled: heapHolder.reconciliationScheduledSessions.size,
-    incrementalTimers: heapHolder.incrementalTimers.size,
-    pendingIncremental: heapHolder.pendingIncrementalKeys.size,
-    activeSessionLocks: heapHolder.sessionLocks.size,
-    completedIncrementalKeys: heapHolder.completedIncrementalKeys.size,
-    activeBufferMessages: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + messages.length, 0),
-    activeBufferBytes: [...heapHolder.activeReconcilerBuffers.values()].reduce((sum, messages) => sum + serializedMessageBytes(messages), 0)
-  };
-}
-
-// src/plugin/sidebar-snapshot-cache.ts
-var MAX_CACHED_SESSIONS = 100;
-var STALE_SNAPSHOT_AGE_MS = 5 * 60 * 1000;
-var cache = new BoundedSessionMap(MAX_CACHED_SESSIONS);
-function applyStickySnapshotCache(sessionId, fresh) {
-  const now = Date.now();
-  if (fresh.inputTokens > 0) {
-    cache.set(sessionId, { snapshot: fresh, cachedAt: now });
-    return fresh;
+// src/plugin/sidebar-snapshot-cache.ts
+var MAX_CACHED_SESSIONS = 100;
+var STALE_SNAPSHOT_AGE_MS = 5 * 60 * 1000;
+var cache = new BoundedSessionMap(MAX_CACHED_SESSIONS);
+function applyStickySnapshotCache(sessionId, fresh) {
+  const now = Date.now();
+  if (fresh.inputTokens > 0) {
+    cache.set(sessionId, { snapshot: fresh, cachedAt: now });
+    return fresh;
   }
   const cached = cache.peek(sessionId);
   if (!cached) {
@@ -6374,6 +6544,24 @@ function createUnifiedSearchDiagnostics() {
     suppressedLiveMessageMatches: 0
   };
 }
+function searchMessageHistory(db, request) {
+  const diagnostics = request.collectDiagnostics ? createUnifiedSearchDiagnostics() : undefined;
+  const results = searchMessages({
+    db,
+    sessionId: request.sessionId,
+    query: request.query,
+    limit: request.limit,
+    maxOrdinal: request.maxOrdinal,
+    probes: request.probes,
+    relaxedRecall: request.relaxedRecall,
+    diagnostics,
+    dateRange: request.dateRange
+  });
+  return {
+    results,
+    suppressedLiveMessageMatches: diagnostics?.suppressedLiveMessageMatches ?? 0
+  };
+}
 function normalizeLimit(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
     return DEFAULT_UNIFIED_SEARCH_LIMIT;
@@ -6900,15 +7088,18 @@ function searchMessagesInSnapshot(args, sessionFirst) {
       args.diagnostics.suppressedLiveMessageMatches = outcome.suppressedCount;
     }
     const rows = outcome.rows.length > 0 || !args.relaxedRecall ? outcome.rows : runMessageFtsQuery(args.db, args.sessionId, relaxedFtsQuery(args.query), fetchLimit, cutoff, args.dateRange, sessionFirst);
-    const filtered = rows.slice(0, args.limit);
-    return filtered.map((row, rank) => ({
-      source: "message",
-      content: previewText(row.content),
-      score: linearDecayScore(rank, filtered.length),
-      messageOrdinal: row.messageOrdinal,
-      messageId: row.messageId,
-      role: row.role
-    }));
+    const renderRows = (limit) => {
+      const filtered = rows.slice(0, limit);
+      return filtered.map((row, rank) => ({
+        source: "message",
+        content: previewText(row.content),
+        score: linearDecayScore(rank, filtered.length),
+        messageOrdinal: row.messageOrdinal,
+        messageId: row.messageId,
+        role: row.role
+      }));
+    };
+    return renderRows(args.limit);
   }
   const sanitizedProbes = probes.map((probe) => ({ probe, query: sanitizeFtsQuery(probe) })).filter((entry) => entry.query.length > 0);
   const corpusSize = getIndexedMessageCorpusSize(args.db, args.sessionId, cutoff);
@@ -6948,39 +7139,42 @@ function searchMessagesInSnapshot(args, sessionFirst) {
     queryLists.push({ rows: rowsByQuery[queryIndex] ?? [], weight });
     queryIndex += 1;
   });
-  const fused = new Map;
-  for (const list of queryLists) {
-    list.rows.forEach((row, rank) => {
-      const rrf = list.weight / (RRF_K + rank);
-      const existing = fused.get(row.messageId);
-      if (existing) {
-        existing.score += rrf;
-      } else {
-        fused.set(row.messageId, { row, score: rrf });
+  const rankProbeLists = (rowLimit, resultLimit) => {
+    const fused = new Map;
+    for (const list of queryLists) {
+      list.rows.slice(0, rowLimit).forEach((row, rank) => {
+        const rrf = list.weight / (RRF_K + rank);
+        const existing = fused.get(row.messageId);
+        if (existing) {
+          existing.score += rrf;
+        } else {
+          fused.set(row.messageId, { row, score: rrf });
+        }
+      });
+    }
+    for (const entry of fused.values()) {
+      let best = 0;
+      for (const probe of probes) {
+        const weight = probeWeights.get(probe) ?? 0;
+        if (weight > best && containsProbeVerbatim(entry.row.content, [probe])) {
+          best = weight;
+        }
       }
-    });
-  }
-  for (const entry of fused.values()) {
-    let best = 0;
-    for (const probe of probes) {
-      const weight = probeWeights.get(probe) ?? 0;
-      if (weight > best && containsProbeVerbatim(entry.row.content, [probe])) {
-        best = weight;
+      if (best > 0) {
+        entry.score += best * VERBATIM_RANK_BONUS;
       }
     }
-    if (best > 0) {
-      entry.score += best * VERBATIM_RANK_BONUS;
-    }
-  }
-  const ranked = [...fused.values()].sort((a, b) => b.score !== a.score ? b.score - a.score : a.row.messageOrdinal - b.row.messageOrdinal).slice(0, args.limit);
-  return ranked.map((entry, rank) => ({
-    source: "message",
-    content: previewText(entry.row.content),
-    score: linearDecayScore(rank, ranked.length),
-    messageOrdinal: entry.row.messageOrdinal,
-    messageId: entry.row.messageId,
-    role: entry.row.role
-  }));
+    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),
+      score: linearDecayScore(rank, ranked.length),
+      messageOrdinal: entry.row.messageOrdinal,
+      messageId: entry.row.messageId,
+      role: entry.row.role
+    }));
+  };
+  return rankProbeLists(fetchLimit, args.limit);
 }
 var NOTE_SEARCHABLE_STATUSES = ["active"];
 var MAX_NOTE_KEYWORD_SCORE = 3.5;
@@ -7270,17 +7464,28 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const runPrimers = activeSources.has("primer") && memoryFeatureEnabled;
   const runNotes = activeSources.has("note");
   const messageProbes = options.explicitSearch ? extractLiteralProbes(trimmedQuery) : [];
-  const messageResults = runMessages ? searchMessages({
-    db,
-    sessionId,
-    query: trimmedQuery,
-    limit: tierLimit,
-    maxOrdinal: options.maxMessageOrdinal,
-    probes: messageProbes,
-    relaxedRecall: options.explicitSearch,
-    diagnostics: options.diagnostics,
-    dateRange
-  }) : [];
+  let messageResults = [];
+  if (runMessages) {
+    const messageRequest = {
+      sessionId,
+      query: trimmedQuery,
+      limit: tierLimit,
+      maxOrdinal: options.maxMessageOrdinal,
+      probes: messageProbes,
+      relaxedRecall: options.explicitSearch,
+      collectDiagnostics: options.diagnostics !== undefined,
+      dateRange
+    };
+    const delegated = options.searchMessageHistory ? await options.searchMessageHistory(messageRequest).catch((error) => {
+      log(`[search] off-thread message search failed: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }) : null;
+    const outcome = delegated ?? searchMessageHistory(db, messageRequest);
+    if (options.diagnostics) {
+      options.diagnostics.suppressedLiveMessageMatches = outcome.suppressedLiveMessageMatches;
+    }
+    messageResults = outcome.results;
+  }
   const workspace = resolveSearchWorkspaceContext(db, projectPath);
   const [memoryOutcome, primerResults, noteResults] = await Promise.all([
     runMemory ? searchMemories({
@@ -7425,7 +7630,7 @@ ${diagnosticLines.join(`
     bodyParts.push(diagnosticLines.join(`
 `));
   if (results.some((result) => result.source === "message")) {
-    bodyParts.push("Use mmc_expand(start, end) with the range from any message result above to read the full conversation context.");
+    bodyParts.push("Use mmc_expand(start, end) with the range from any message result above to read the conversation context. If the host no longer holds those messages, mmc_expand returns indexed text from the search archive only, with no surrounding messages or tool output.");
   }
   if (results.some((result) => result.source === "note" && result.anchorOrdinal !== null && result.sourceSessionId === currentSessionId)) {
     bodyParts.push(SEARCH_NOTE_EXPAND_HINT);
@@ -7437,23 +7642,6 @@ ${bodyParts.join(`
 `)}`;
 }
 
-// src/shared/auto-search-lifecycle.ts
-var pending = new Map;
-function registerAutoSearchWork(sessionId) {
-  const controller = new AbortController;
-  const work = pending.get(sessionId) ?? new Set;
-  pending.set(sessionId, work);
-  work.add(controller);
-  return {
-    signal: controller.signal,
-    done: () => {
-      work.delete(controller);
-      if (pending.get(sessionId) === work && work.size === 0)
-        pending.delete(sessionId);
-    }
-  };
-}
-
 // src/hooks/magic-context/auto-search-deadline.ts
 var AUTO_SEARCH_TIMEOUT_MS = 3000;
 var operationDeadlines = new WeakMap;
@@ -8227,6 +8415,8 @@ async function runAutoSearchHint(args) {
     return AUTO_SEARCH_OK;
   }
   const replayServedDecision = () => {
+    if (getUnpublishedAutoSearchNoHint(sessionId, userMsgId) !== undefined)
+      return;
     const decisions = getAutoSearchHintDecisions(db, sessionId);
     const decision = decisions.find((entry) => entry.messageId === userMsgId);
     if (decision?.decision === "hint") {
@@ -8239,12 +8429,34 @@ async function runAutoSearchHint(args) {
     if (messages.length === 0 || messages[messages.length - 1].info.id !== userMsgId) {
       return AUTO_SEARCH_OK;
     }
+    const unpublishedReason = getUnpublishedAutoSearchNoHint(sessionId, userMsgId);
+    if (unpublishedReason !== undefined) {
+      try {
+        const outcome = appendAutoSearchHintDecision(db, sessionId, {
+          messageId: userMsgId,
+          decision: "no-hint",
+          reason: unpublishedReason
+        });
+        if (outcome.ok)
+          forgetUnpublishedAutoSearchNoHint(sessionId, userMsgId);
+      } catch {}
+      return AUTO_SEARCH_OK;
+    }
     const writeNoHintAndReconcile = (reason) => {
-      const outcome = appendAutoSearchHintDecision(db, sessionId, {
-        messageId: userMsgId,
-        decision: "no-hint",
-        reason
-      });
+      let outcome;
+      try {
+        outcome = appendAutoSearchHintDecision(db, sessionId, {
+          messageId: userMsgId,
+          decision: "no-hint",
+          reason
+        });
+      } catch (error) {
+        if (isTransientSqliteError(error)) {
+          rememberUnpublishedAutoSearchNoHint(sessionId, userMsgId, reason);
+          return { ok: false, kind: "storage-busy" };
+        }
+        throw error;
+      }
       if (!outcome.ok)
         return { ok: false, kind: "cas-exhaustion" };
       if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
@@ -8281,8 +8493,11 @@ async function runAutoSearchHint(args) {
         });
       }, startedAt);
     } catch (error) {
-      log(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error instanceof Error ? error.message : String(error)}`);
-      return { ok: false, kind: "search-failure" };
+      if (lifecycleSignal.aborted)
+        return AUTO_SEARCH_OK;
+      log(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
+      const outcome = writeNoHintAndReconcile("error");
+      return outcome.ok ? { ok: false, kind: "search-failure" } : outcome;
     }
     if (results === null) {
       persistAutoSearchSkip(db, sessionId, userMsgId, "timeout");
@@ -8510,7 +8725,7 @@ function createChatMessageHook(args) {
         sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}), triggering flush`);
         args.historyRefreshSessions.add(sessionId);
         args.systemPromptRefreshSessions.add(sessionId);
-        args.pendingMaterializationSessions.add(sessionId);
+        requestPendingMaterialization(args.pendingMaterializationSessions, sessionId, "variant_change");
         args.lastHeuristicsTurnId.delete(sessionId);
       } else {
         sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}) on ${providerID ?? "unknown"}/${modelID ?? "unknown"} without a proven natural cache bust; deferring flush to next natural bust`);
@@ -8635,8 +8850,12 @@ function createToolExecuteAfterHook(args) {
 
 // src/hooks/magic-context/active-anthropic-turn.ts
 function isInActiveAnthropicTurn(messages, index, anthropic) {
+  const start = activeAnthropicTurnStart(messages, anthropic);
+  return start !== undefined && index >= start;
+}
+function activeAnthropicTurnStart(messages, anthropic) {
   if (!anthropic)
-    return false;
+    return;
   for (let user = messages.length - 1;user >= 0; user--) {
     const message = messages[user];
     if (!isRecord(message))
@@ -8650,9 +8869,9 @@ function isInActiveAnthropicTurn(messages, index, anthropic) {
     const parts = Array.isArray(message.parts) ? message.parts : Array.isArray(message.content) ? message.content : [];
     if (parts.length > 0 && parts.every((part) => isRecord(part) && (part.synthetic === true || part.ignored === true || ["tool_result", "toolResult", "tool-result"].includes(String(part.type)))))
       continue;
-    return index > user;
+    return user + 1;
   }
-  return false;
+  return;
 }
 function hasAnthropicReasoning(messages) {
   return messages.some((message) => {
@@ -8666,6 +8885,27 @@ function hasAnthropicReasoning(messages) {
   });
 }
 
+// src/shared/processed-image-eligibility.ts
+function createProcessedImageEligibility(messages, messageTagNumbers, options) {
+  const ageTags = new Map;
+  let nextTag;
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    const ownTag = messageTagNumbers.get(message);
+    if (ownTag !== undefined && Number.isFinite(ownTag) && ownTag > 0)
+      nextTag = ownTag;
+    if (nextTag !== undefined)
+      ageTags.set(message, nextTag);
+  }
+  return {
+    ageTags,
+    mayStrip: (message) => {
+      const age = ageTags.get(message);
+      return options.watermark > 0 && age !== undefined && age <= options.watermark && ((options.contextPercentage ?? 0) >= 95 || options.protectedCutoff == null || age < options.protectedCutoff);
+    }
+  };
+}
+
 // src/hooks/magic-context/strip-content.ts
 var MARKER_ONLY_PATTERN = /^(?:(?:§\d+§|\[dropped(?: §\d+§)?\]|\[cleared\])\s*)+$/;
 function isMarkerOnlyText(text) {
@@ -8728,8 +8968,7 @@ function stripSystemInjectedMessages(messages, protectedTailStart, providerID, o
     }
     if (hasContentPart && allContentIsSystemInjection) {
       onFirstApplication?.(msg, 0);
-      msg.parts.length = 0;
-      msg.parts.push(makeWholeMessageSentinel(providerID));
+      neutralizeWholeMessage(msg, providerID);
       stripped++;
       if (typeof msg.info.id === "string")
         sentineledIds.push(msg.info.id);
@@ -8787,8 +9026,7 @@ function stripDroppedPlaceholderMessages(messages, providerID, onFirstApplicatio
     }
     if (hasContentPart && !hasNonDroppedContent) {
       onFirstApplication?.(msg, 0);
-      msg.parts.length = 0;
-      msg.parts.push(makeWholeMessageSentinel(providerID));
+      neutralizeWholeMessage(msg, providerID);
       stripped++;
       if (typeof msg.info.id === "string")
         sentineledIds.push(msg.info.id);
@@ -9187,7 +9425,7 @@ function stripReasoningFromMergedAssistants(messages, providerID, options) {
   if (providerID !== "anthropic")
     return 0;
   let stripped = 0;
-  const frozenParts = readFrozenMergedReasoningParts(options?.frozenMessageIds ?? new Set);
+  const frozenParts = options?.frozenParts ?? readFrozenMergedReasoningParts(options?.frozenMessageIds ?? new Set);
   for (const message of messages) {
     if (message.info.role !== "assistant" || options?.restoreMessages?.has(message))
       continue;
@@ -9204,7 +9442,7 @@ function stripReasoningFromMergedAssistants(messages, providerID, options) {
       stripped++;
     }
   }
-  for (const entry of planMergedAssistantReasoningStrip(messages, options?.mutationExemptMessage, new Set(frozenParts.keys()), options?.frozenMessageIds ? options.restoreMessages : options?.protectedMessages)) {
+  for (const entry of planMergedAssistantReasoningStrip(messages, options?.mutationExemptMessage, options?.frozenPartMessageIds ?? new Set(frozenParts.keys()), options?.frozenMessageIds ? options.restoreMessages : options?.protectedMessages)) {
     if (options?.frozenMessageIds) {
       const id = entry.message.info.id;
       if (typeof id !== "string" || !options.frozenMessageIds.has(id))
@@ -9217,50 +9455,142 @@ function stripReasoningFromMergedAssistants(messages, providerID, options) {
   }
   return stripped;
 }
+var emptyImageParts = new WeakMap;
+function getEmptyImageParts(messages) {
+  return emptyImageParts.get(messages) ?? new Map;
+}
+function imageOmissionBreaksStructure(messages, index, omitted) {
+  let before = index - 1;
+  let after = index + 1;
+  while (omitted.has(before))
+    before--;
+  while (omitted.has(after))
+    after++;
+  const previous = messages[before];
+  const next = messages[after];
+  return previous !== undefined && next !== undefined && previous.info.role === next.info.role;
+}
 function stripProcessedImages(messages, frozenIds, options) {
-  const { detect, watermark, messageTagNumbers } = options;
+  const omissions = new Map;
+  emptyImageParts.set(messages, omissions);
+  const { detect, messageTagNumbers } = options;
+  const eligibility = createProcessedImageEligibility(messages, messageTagNumbers, options);
   let stripped = 0;
   const newlyStrippedIds = [];
+  const planned = [];
+  const newMarkers = new Map;
   let hasAssistantResponse = false;
   for (let i = messages.length - 1;i >= 0; i--) {
     const msg = messages[i];
+    const answered = hasAssistantResponse;
     if (msg.info.role === "assistant") {
       hasAssistantResponse = true;
-      continue;
     }
-    if (msg.info.role !== "user") {
+    if (msg.info.role !== "user" && msg.info.role !== "assistant") {
       continue;
     }
     const id = typeof msg.info.id === "string" ? msg.info.id : undefined;
     const inFrozen = id !== undefined && frozenIds.has(id);
-    const maxTag = messageTagNumbers.get(msg) ?? 0;
-    const isNewDetection = !inFrozen && detect && hasAssistantResponse && id !== undefined && maxTag <= watermark;
+    const isNewDetection = !inFrozen && detect && answered && id !== undefined && eligibility.mayStrip(msg) && !options.protectedMessageIds?.has(id);
     if (!inFrozen && !isNewDetection) {
       continue;
     }
     let touchedThisMsg = false;
     for (let j = 0;j < msg.parts.length; j++) {
       const part = msg.parts[j];
-      if (!isRecord(part) || part.type !== "file") {
-        continue;
-      }
-      if (typeof part.mime !== "string" || !part.mime.startsWith("image/")) {
-        continue;
-      }
-      if (typeof part.url === "string" && part.url.startsWith("data:") && part.url.length > 200) {
-        if (isNewDetection)
-          options.onFirstApplication?.(msg, j);
-        msg.parts[j] = makeSentinel(part);
-        stripped++;
+      const tool = msg.info.role === "assistant" && isRecord(part) && part.type === "tool" && isRecord(part.state) && part.state.status === "completed";
+      const images = tool && isRecord(part) && isRecord(part.state) && Array.isArray(part.state.attachments) ? part.state.attachments : msg.info.role === "user" ? [part] : [];
+      if (images.some(isProcessedImagePart)) {
+        planned.push({
+          message: msg,
+          partIndex: j,
+          firstApplication: isNewDetection,
+          tool
+        });
         touchedThisMsg = true;
       }
     }
     if (touchedThisMsg && isNewDetection && id !== undefined) {
       newlyStrippedIds.push(id);
+      newMarkers.set(id, msg.info.role === "assistant" ? "[image stripped]" : options.replacementText ?? "");
+    }
+  }
+  const imageIndices = new Map;
+  for (const { message, partIndex, tool } of planned) {
+    if (tool)
+      continue;
+    const indices = imageIndices.get(message) ?? new Set;
+    indices.add(partIndex);
+    imageIndices.set(message, indices);
+  }
+  const emptiedRows = new Set;
+  const newEmptyRows = [];
+  for (let index = 0;index < messages.length; index++) {
+    const message = messages[index];
+    if (message.parts.every((part) => isRecord(part) && part.type === "text" && part.text === ""))
+      emptiedRows.add(index);
+    const id = message.info.id;
+    const indices = imageIndices.get(message);
+    if (!id || !indices)
+      continue;
+    const marker = options.frozenMarkers?.get(id) ?? newMarkers.get(id) ?? "";
+    if (marker !== "" || !message.parts.every((part, partIndex) => indices.has(partIndex) || isRecord(part) && part.type === "text" && part.text === ""))
+      continue;
+    if (newMarkers.has(id))
+      newEmptyRows.push({ index, id });
+    else
+      emptiedRows.add(index);
+  }
+  for (const { index, id } of newEmptyRows) {
+    if (imageOmissionBreaksStructure(messages, index, emptiedRows))
+      newMarkers.set(id, "[image stripped]");
+    else
+      emptiedRows.add(index);
+  }
+  const persisted = newlyStrippedIds.length === 0 || options.persistNewIds?.(newlyStrippedIds, newMarkers) !== false;
+  if (!persisted)
+    newlyStrippedIds.length = 0;
+  for (const { message, partIndex, firstApplication, tool } of planned) {
+    if (firstApplication && !persisted)
+      continue;
+    if (firstApplication)
+      options.onFirstApplication?.(message, partIndex);
+    const marker = tool ? "[image stripped]" : options.frozenMarkers?.get(message.info.id ?? "") ?? (firstApplication ? newMarkers.get(message.info.id ?? "") : "") ?? "";
+    const original = message.parts[partIndex];
+    if (tool && isRecord(original) && isRecord(original.state) && Array.isArray(original.state.attachments)) {
+      const attachments = original.state.attachments;
+      const count = attachments.filter(isProcessedImagePart).length;
+      const output = typeof original.state.output === "string" ? original.state.output : "";
+      message.parts[partIndex] = {
+        ...original,
+        state: {
+          ...original.state,
+          output: [output, ...Array(count).fill(marker)].filter(Boolean).join(`
+`),
+          attachments: attachments.filter((part) => !isProcessedImagePart(part))
+        }
+      };
+      stripped += count;
+    } else {
+      message.parts[partIndex] = { ...makeSentinel(original), text: marker };
+      if (marker === "" && message.info.id) {
+        const indices = omissions.get(message.info.id) ?? new Set;
+        indices.add(partIndex);
+        omissions.set(message.info.id, indices);
+      }
+      stripped++;
     }
   }
   return { stripped, newlyStrippedIds };
 }
+function isProcessedImagePart(part) {
+  if (isRecord(part) && part.type === "media" && isRecord(part.media)) {
+    const { source, mediaType } = part.media;
+    const inlineLength = isRecord(source) ? source.type === "base64" && typeof source.data === "string" ? source.data.length : source.type === "bytes" && source.data instanceof Uint8Array ? Math.ceil(source.data.byteLength / 3) * 4 : 0 : 0;
+    return typeof mediaType === "string" && mediaType.startsWith("image/") && inlineLength > 0 && inlineLength + `data:${mediaType};base64,`.length > 200;
+  }
+  return isRecord(part) && part.type === "file" && typeof part.mime === "string" && part.mime.startsWith("image/") && typeof part.url === "string" && part.url.startsWith("data:") && part.url.length > 200;
+}
 
 // src/hooks/magic-context/reasoning-removal.ts
 var REMOVABLE_REASONING_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
@@ -9510,7 +9840,7 @@ function armLatestThinkingRecovery(db, sessionId) {
   ensureSessionMetaRow(db, sessionId);
   const current = getThinkingBindingRecoveryTarget(db, sessionId);
   const anchor = lastPassTurnAnchor.get(sessionId);
-  const next = current?.startsWith(ACTIVE) ? UNRECOVERABLE + ":" + current.slice(ACTIVE.length) : current?.startsWith(UNRECOVERABLE) || current?.startsWith(ARMED) ? current : anchor !== undefined ? ARMED + anchor : LATEST_THINKING_RESTORE;
+  const next = current?.startsWith(ACTIVE) ? `${UNRECOVERABLE}:${current.slice(ACTIVE.length)}` : current?.startsWith(UNRECOVERABLE) || current?.startsWith(ARMED) ? current : anchor !== undefined ? `${ARMED}${anchor}` : LATEST_THINKING_RESTORE;
   db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = ? WHERE session_id = ?").run(next, sessionId);
 }
 function clone(value) {
@@ -9543,12 +9873,12 @@ function prepareLatestThinkingRecovery(args) {
   let target;
   try {
     target = getThinkingBindingRecoveryTarget(args.db, args.sessionId);
-  } catch (error) {
+  } catch {
     if (knownRejectedSessions.has(args.sessionId))
       throw contextRefusalError(LATEST_THINKING_UNSAFE);
     return { restore: false, ended: false };
   }
-  if (!target || !target.startsWith(LATEST_THINKING_RESTORE)) {
+  if (!target?.startsWith(LATEST_THINKING_RESTORE)) {
     knownRejectedSessions.delete(args.sessionId);
     return { restore: false, ended: false };
   }
@@ -9559,7 +9889,7 @@ function prepareLatestThinkingRecovery(args) {
     return { restore: false, ended: false };
   }
   knownRejectedSessions.add(args.sessionId);
-  const savedAnchor = target.startsWith(ACTIVE) ? target.slice(ACTIVE.length) : target.startsWith(UNRECOVERABLE + ":") ? target.slice(UNRECOVERABLE.length + 1) : undefined;
+  const savedAnchor = target.startsWith(ACTIVE) ? target.slice(ACTIVE.length) : target.startsWith(`${UNRECOVERABLE}:`) ? target.slice(UNRECOVERABLE.length + 1) : undefined;
   if (savedAnchor !== undefined && savedAnchor !== anchor) {
     args.db.prepare("UPDATE session_meta SET thinking_binding_recovery_target = '' WHERE session_id = ? AND thinking_binding_recovery_target = ?").run(args.sessionId, target);
     knownRejectedSessions.delete(args.sessionId);
@@ -9572,7 +9902,7 @@ function prepareLatestThinkingRecovery(args) {
   }
   const active = args.messages.slice(start);
   if (!active.some((message) => args.parts(message).some(replayableOriginal)))
-    throw contextRefusalError(LATEST_THINKING_UNSAFE + " [missing-thinking-original]");
+    throw contextRefusalError(`${LATEST_THINKING_UNSAFE} [missing-thinking-original]`);
   const ids = new Map(args.messages.map((message, index) => [args.id(message, index), index]));
   for (const decision of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
     if (decision === "binding_mismatch_order:end" || decision === TOOL_SWEEP_SCOPED_MARKER)
@@ -9580,7 +9910,7 @@ function prepareLatestThinkingRecovery(args) {
     const id = decodeMergedReasoningParts(decision)?.[0] ?? (decision.startsWith("binding_mismatch:") ? decision.slice("binding_mismatch:".length) : decision);
     const index = ids.get(id);
     if (index === undefined || index >= start && !args.parts(args.messages[index]).some(replayableOriginal))
-      throw contextRefusalError(LATEST_THINKING_UNSAFE + ` [missing-original:${id}]`);
+      throw contextRefusalError(`${LATEST_THINKING_UNSAFE} [missing-original:${id}]`);
   }
   return { restore: true, ended: false };
 }
@@ -9613,964 +9943,6 @@ function armLatestThinkingRecoveryFromError(args) {
   return true;
 }
 
-// src/hooks/magic-context/lkg-measured-request.ts
-import { createHash as createHash3 } from "node:crypto";
-
-// src/shared/provider-response-completion.ts
-function providerResponseFailed(input) {
-  if (input.error !== undefined && input.error !== null && input.error !== "")
-    return true;
-  const finish = typeof input.finish === "string" ? input.finish.trim().toLowerCase() : "";
-  return ["error", "failed", "abort", "aborted", "interrupted", "cancelled", "canceled"].includes(finish);
-}
-function isSuccessfulProviderCompletion(input) {
-  if (providerResponseFailed(input))
-    return false;
-  return typeof input.completedAt === "number" && Number.isFinite(input.completedAt) && input.completedAt > 0 || typeof input.finish === "string" && input.finish.trim().length > 0;
-}
-
-// src/hooks/magic-context/lkg-measured-request.ts
-var requests = new BoundedSessionMap(1000);
-var claimedRequests = new WeakSet;
-var captures = new BoundedSessionMap(1000);
-function lkgProviderInputTotal(tokens) {
-  const counts = [tokens?.input ?? 0, tokens?.cache?.read ?? 0, tokens?.cache?.write ?? 0];
-  return counts.every((count) => Number.isSafeInteger(count) && count >= 0) ? counts.reduce((sum, count) => sum + count, 0) : Number.NaN;
-}
-function identity(slot) {
-  return createHash3("sha256").update(JSON.stringify([
-    slot.capturedAt,
-    slot.captureSequence,
-    slot.rowVersion,
-    slot.modelKey,
-    slot.providerKey,
-    slot.inputIdSeq,
-    slot.inputContentDigests
-  ])).update(slot.jsonPrefix).digest("hex");
-}
-function envelope(modelKey, systemPromptTokens, agentName) {
-  const slash = modelKey.indexOf("/");
-  return JSON.stringify([
-    modelKey,
-    systemPromptTokens,
-    agentName,
-    getMeasuredToolDefinitionTokens(modelKey.slice(0, slash), modelKey.slice(slash + 1), agentName)
-  ]);
-}
-function beginV2LkgRequest(sessionId, modelKey, previousResponseId) {
-  requests.set(sessionId, { kind: "v2", previousResponseId, startedAt: Date.now(), modelKey });
-}
-function claimLkgRequestIdentity(sessionId) {
-  const request = requests.get(sessionId);
-  if (!request || claimedRequests.has(request))
-    return;
-  claimedRequests.add(request);
-  return request;
-}
-function noteCapturedLkgRequest(args) {
-  const request = args.request;
-  if (!request || request.modelKey !== args.slot.modelKey) {
-    captures.delete(args.sessionId);
-    return;
-  }
-  captures.set(args.sessionId, {
-    request,
-    slot: identity(args.slot),
-    prefixCount: JSON.parse(args.slot.jsonPrefix).length,
-    envelope: envelope(request.modelKey, args.systemPromptTokens, args.agentName)
-  });
-}
-function noteLkgProviderResponse(args) {
-  if (!args.responseId || !args.modelKey)
-    return;
-  if (!args.v2 && args.inputTokens === 0 && !args.completedAt && !args.finish && !args.error) {
-    const previous = requests.get(args.sessionId);
-    if (previous?.kind === "v1" && previous.responseId === args.responseId && previous.modelKey === args.modelKey)
-      return;
-    requests.set(args.sessionId, {
-      kind: "v1",
-      responseId: args.responseId,
-      modelKey: args.modelKey
-    });
-    return;
-  }
-  const capture = captures.get(args.sessionId);
-  if (!capture || capture.usage || capture.request.modelKey !== args.modelKey || !Number.isSafeInteger(args.inputTokens) || args.inputTokens <= 0 || providerResponseFailed(args) || !args.completedAt && !args.finish)
-    return;
-  const request = capture.request;
-  if (request.kind === "v1") {
-    if (args.v2 || request.responseId !== args.responseId)
-      return;
-  } else if (!args.v2 || requests.get(args.sessionId) !== request || request.previousResponseId === args.responseId || args.createdAt === undefined || args.createdAt < request.startedAt)
-    return;
-  capture.usage = { responseId: args.responseId, inputTokens: args.inputTokens };
-}
-
-// src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash4 } from "node:crypto";
-function parseStringArray(value) {
-  if (typeof value !== "string")
-    return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    return null;
-  }
-  if (!Array.isArray(parsed))
-    return null;
-  const result = [];
-  for (const entry of parsed) {
-    if (typeof entry !== "string" || entry.length === 0)
-      return null;
-    result.push(entry);
-  }
-  return result;
-}
-function parseNullableString(value) {
-  if (value === null || value === undefined)
-    return null;
-  return typeof value === "string" ? value : undefined;
-}
-function parseNullableInteger(value) {
-  if (value === null || value === undefined)
-    return;
-  return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
-}
-function parsePersistedLkgSlot(row) {
-  if (!row || typeof row !== "object")
-    return;
-  const record = row;
-  const jsonPrefix = record.json_prefix;
-  const lastInputMessageId = record.last_input_message_id;
-  const capturedAt = record.captured_at;
-  let inputIdsRaw = record.input_id_seq;
-  let piOutputEntryIds;
-  if (typeof inputIdsRaw === "string") {
-    try {
-      const metadata = JSON.parse(inputIdsRaw);
-      if (metadata && !Array.isArray(metadata) && metadata.version === 1 && Array.isArray(metadata.piOutputEntryIds)) {
-        if (!metadata.piOutputEntryIds.every((id) => id === null || typeof id === "string" && id.length > 0))
-          return;
-        piOutputEntryIds = metadata.piOutputEntryIds;
-        inputIdsRaw = JSON.stringify(metadata.inputIds);
-      }
-    } catch {
-      return;
-    }
-  }
-  const inputIdSeq = parseStringArray(inputIdsRaw);
-  const inputContentDigests = parseStringArray(record.input_content_digests);
-  const modelKey = parseNullableString(record.model_key);
-  const providerKey = parseNullableString(record.provider_key);
-  if (typeof jsonPrefix !== "string" || typeof lastInputMessageId !== "string" || lastInputMessageId.length === 0 || typeof capturedAt !== "number" || !Number.isFinite(capturedAt) || inputIdSeq === null || inputContentDigests === null || inputContentDigests.length !== inputIdSeq.length || modelKey === undefined || providerKey === undefined) {
-    return;
-  }
-  if (piOutputEntryIds) {
-    try {
-      const output = JSON.parse(jsonPrefix);
-      const inputs = new Set(inputIdSeq);
-      if (!Array.isArray(output) || output.length !== piOutputEntryIds.length || piOutputEntryIds.some((id) => id !== null && !inputs.has(id)))
-        return;
-    } catch {
-      return;
-    }
-  }
-  let inputContentSignatures;
-  if (record.input_content_signatures !== null && record.input_content_signatures !== undefined) {
-    const parsed = parseStringArray(record.input_content_signatures);
-    if (parsed === null || parsed.length !== inputIdSeq.length)
-      return;
-    inputContentSignatures = parsed;
-  }
-  const slot = {
-    jsonPrefix,
-    inputIdSeq,
-    inputContentDigests,
-    lastInputMessageId,
-    modelKey,
-    providerKey,
-    capturedAt
-  };
-  if (inputContentSignatures)
-    slot.inputContentSignatures = inputContentSignatures;
-  if (piOutputEntryIds)
-    slot.piOutputEntryIds = piOutputEntryIds;
-  const rowVersion = parseNullableInteger(record.row_version);
-  if (rowVersion !== undefined)
-    slot.rowVersion = rowVersion;
-  const captureSequence = parseNullableInteger(record.capture_sequence);
-  if (captureSequence !== undefined)
-    slot.captureSequence = captureSequence;
-  return slot;
-}
-var persistedFingerprints = new WeakMap;
-var PERSISTED_FINGERPRINT_MAX_SESSIONS = 1000;
-function rememberFingerprint(db, sessionId, fingerprint) {
-  let saved = persistedFingerprints.get(db);
-  if (!saved) {
-    saved = new Map;
-    persistedFingerprints.set(db, saved);
-  }
-  saved.delete(sessionId);
-  if (saved.size >= PERSISTED_FINGERPRINT_MAX_SESSIONS) {
-    const oldest = saved.keys().next().value;
-    if (oldest !== undefined)
-      saved.delete(oldest);
-  }
-  saved.set(sessionId, fingerprint);
-}
-function slotFingerprint(slot) {
-  return createHash4("sha256").update(JSON.stringify([
-    slot.jsonPrefix,
-    slot.inputIdSeq,
-    slot.inputContentDigests,
-    slot.inputContentSignatures,
-    slot.piOutputEntryIds,
-    slot.lastInputMessageId,
-    slot.modelKey,
-    slot.providerKey,
-    slot.rowVersion,
-    slot.captureSequence
-  ])).digest("hex");
-}
-function saveLkgSlotToDb(db, sessionId, slot) {
-  const fingerprint = slotFingerprint(slot);
-  if (persistedFingerprints.get(db)?.get(sessionId) === fingerprint)
-    return true;
-  const layout = layoutLkgPrefix(slot.jsonPrefix);
-  try {
-    db.transaction(() => {
-      const storedHashes = new Map;
-      for (const row of db.prepare("SELECT chunk, hash FROM lkg_slot_chunks WHERE session_id = ?").all(sessionId)) {
-        storedHashes.set(row.chunk, row.hash);
-      }
-      const upsertChunk = db.prepare(`INSERT INTO lkg_slot_chunks (session_id, chunk, hash, body) VALUES (?, ?, ?, ?)
-                ON CONFLICT(session_id, chunk) DO UPDATE SET hash = excluded.hash, body = excluded.body`);
-      for (let index = 0;index < layout.chunks.length; index += 1) {
-        if (storedHashes.get(index) === layout.chunkHashes[index])
-          continue;
-        upsertChunk.run(sessionId, index, layout.chunkHashes[index], layout.chunks[index]);
-      }
-      db.prepare("DELETE FROM lkg_slot_chunks WHERE session_id = ? AND chunk >= ?").run(sessionId, layout.chunks.length);
-      db.prepare(`INSERT INTO lkg_slots (
-                    session_id, json_prefix_chars, json_prefix_chunks, json_prefix_hash,
-                    input_id_seq, input_content_digests, input_content_signatures,
-                    last_input_message_id, model_key, provider_key,
-                    captured_at, row_version, capture_sequence
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(session_id) DO UPDATE SET
-                    json_prefix_chars = excluded.json_prefix_chars,
-                    json_prefix_chunks = excluded.json_prefix_chunks,
-                    json_prefix_hash = excluded.json_prefix_hash,
-                    input_id_seq = excluded.input_id_seq,
-                    input_content_digests = excluded.input_content_digests,
-                    input_content_signatures = excluded.input_content_signatures,
-                    last_input_message_id = excluded.last_input_message_id,
-                    model_key = excluded.model_key,
-                    provider_key = excluded.provider_key,
-                    captured_at = excluded.captured_at,
-                    row_version = excluded.row_version,
-                    capture_sequence = excluded.capture_sequence`).run(sessionId, layout.chars, layout.chunks.length, layout.hash, JSON.stringify(slot.piOutputEntryIds ? {
-        version: 1,
-        inputIds: slot.inputIdSeq,
-        piOutputEntryIds: slot.piOutputEntryIds
-      } : slot.inputIdSeq), JSON.stringify(slot.inputContentDigests), slot.inputContentSignatures ? JSON.stringify(slot.inputContentSignatures) : null, slot.lastInputMessageId, slot.modelKey, slot.providerKey, slot.capturedAt, slot.rowVersion ?? null, slot.captureSequence ?? null);
-    }).immediate();
-    rememberFingerprint(db, sessionId, fingerprint);
-    return true;
-  } catch (error) {
-    sessionLog(sessionId, "LKG snapshot persistence failed (in-memory slot retained):", error);
-    return false;
-  }
-}
-function clearPersistedLkgSlot(db, sessionId) {
-  try {
-    db.transaction(() => {
-      db.prepare("DELETE FROM lkg_slot_chunks WHERE session_id = ?").run(sessionId);
-      db.prepare("DELETE FROM lkg_slots WHERE session_id = ?").run(sessionId);
-    }).immediate();
-    persistedFingerprints.get(db)?.delete(sessionId);
-  } catch (error) {
-    sessionLog(sessionId, "LKG snapshot durable clear failed:", error);
-  }
-}
-function loadPersistedLkgSlot(db, sessionId) {
-  let row;
-  let chunkRows;
-  try {
-    ({ row, chunkRows } = db.transaction(() => {
-      const slotRow = db.prepare("SELECT * FROM lkg_slots WHERE session_id = ?").get(sessionId);
-      if (!slotRow)
-        return { row: undefined, chunkRows: [] };
-      const slices = db.prepare("SELECT chunk, hash, body FROM lkg_slot_chunks WHERE session_id = ? ORDER BY chunk").all(sessionId);
-      return { row: slotRow, chunkRows: slices };
-    }).deferred());
-  } catch (error) {
-    sessionLog(sessionId, "LKG snapshot durable load failed:", error);
-    return;
-  }
-  if (!row)
-    return;
-  const prefix = assembleLkgPrefix({
-    chars: row.json_prefix_chars,
-    chunks: row.json_prefix_chunks,
-    hash: row.json_prefix_hash
-  }, chunkRows);
-  const slot = prefix ? parsePersistedLkgSlot({ ...row, json_prefix: prefix.jsonPrefix }) : undefined;
-  if (!prefix || !slot) {
-    if (!prefix)
-      sessionLog(sessionId, "LKG snapshot slices failed verification; slot cleared");
-    clearPersistedLkgSlot(db, sessionId);
-    return;
-  }
-  return slot;
-}
-function pruneStaleLkgSlotsBatch(db, now) {
-  const previousTimeout = db.prepare("PRAGMA busy_timeout").get();
-  const cutoff = now - 7 * 24 * 60 * 60 * 1000;
-  const stale = `captured_at < ? AND NOT EXISTS (
-        SELECT 1 FROM session_projects sp
-        WHERE sp.session_id = lkg_slots.session_id AND sp.updated_at >= ?
-    )`;
-  const slot = db.prepare(`SELECT session_id FROM lkg_slots WHERE ${stale} LIMIT 1`).get(cutoff, cutoff);
-  const chunks = db.prepare(`SELECT rowid FROM lkg_slot_chunks c WHERE
-        session_id = ? OR NOT EXISTS (SELECT 1 FROM lkg_slots s WHERE s.session_id = c.session_id)
-        LIMIT 25`).all(slot?.session_id ?? "");
-  if (!slot && chunks.length === 0)
-    return { slots: 0, chunks: 0 };
-  try {
-    db.exec("PRAGMA busy_timeout = 0");
-    let transactionStartedAt = 0;
-    const changes = db.transaction(() => {
-      transactionStartedAt = performance.now();
-      const removed = slot ? db.prepare(`DELETE FROM lkg_slots WHERE session_id = ? AND ${stale}`).run(slot.session_id, cutoff, cutoff).changes : 0;
-      const removeChunk = db.prepare(`DELETE FROM lkg_slot_chunks WHERE rowid = ? AND NOT EXISTS (
-                SELECT 1 FROM lkg_slots s WHERE s.session_id = lkg_slot_chunks.session_id
-            )`);
-      let removedChunks = 0;
-      for (const { rowid } of chunks)
-        removedChunks += removeChunk.run(rowid).changes;
-      return { slots: removed, chunks: removedChunks };
-    }).immediate();
-    logSlowWriteTransaction("lkg_stale_gc", transactionStartedAt);
-    if (changes.slots && slot)
-      persistedFingerprints.get(db)?.delete(slot.session_id);
-    return changes;
-  } finally {
-    db.exec(`PRAGMA busy_timeout = ${Number(previousTimeout.timeout) || 0}`);
-  }
-}
-function pruneStaleLkgSlots(db, now = Date.now()) {
-  return pruneStaleLkgSlotsBatch(db, now).slots;
-}
-
-// src/hooks/magic-context/openai-compat-adjacency.ts
-function assertOpenAiCompatAdjacency(messages) {
-  const violations = [];
-  for (let i = 0;i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role !== "assistant" || !msg.tool_calls || msg.tool_calls.length === 0) {
-      continue;
-    }
-    const expectedIds = msg.tool_calls.map((tc) => tc.id);
-    const expectedSet = new Set(expectedIds);
-    const collected = new Map;
-    let j = i + 1;
-    while (j < messages.length && messages[j].role === "tool") {
-      const toolMsg = messages[j];
-      const id = toolMsg.tool_call_id;
-      if (!id) {
-        violations.push({
-          index: i,
-          kind: "unmatched_tool_call_id",
-          detail: `tool message at index ${j} missing tool_call_id`
-        });
-      } else if (!expectedSet.has(id)) {
-        violations.push({
-          index: i,
-          kind: "unmatched_tool_call_id",
-          toolCallId: id,
-          assistantToolCallIds: expectedIds,
-          detail: `tool message at index ${j} references unexpected id ${id}`
-        });
-      } else {
-        collected.set(id, j);
-      }
-      j++;
-    }
-    const followingRoles = messages.slice(i + 1, Math.min(messages.length, i + 4)).map((m) => m.role);
-    const missing = expectedIds.filter((id) => !collected.has(id));
-    if (missing.length > 0) {
-      violations.push({
-        index: i,
-        kind: "missing_tool_messages",
-        assistantToolCallIds: expectedIds,
-        followingRoles,
-        detail: missing.length === expectedIds.length ? `assistant at index ${i} has tool_calls but next messages are not contiguous tool role (following: ${followingRoles.join(", ") || "none"})` : `assistant at index ${i} missing tool results for: ${missing.join(", ")}`
-      });
-      if (j < messages.length && messages[j].role !== "tool") {
-        const last = violations[violations.length - 1];
-        last.detail += `; blocked by ${messages.slice(i + 1, j + 1).map((m, off) => `${m.role}[${i + 1 + off}]`).join(", ")}`;
-      }
-    }
-  }
-  for (let i = 0;i < messages.length; i++) {
-    if (messages[i].role !== "tool")
-      continue;
-    const id = messages[i].tool_call_id ?? "";
-    if (!id)
-      continue;
-    let found = false;
-    for (let k = i - 1;k >= 0; k--) {
-      const prev = messages[k];
-      if (prev.role === "assistant" && prev.tool_calls?.some((tc) => tc.id === id)) {
-        const between = messages.slice(k + 1, i);
-        if (between.every((m) => m.role === "tool")) {
-          found = true;
-        }
-        break;
-      }
-      if (prev.role === "assistant" || prev.role === "user")
-        break;
-    }
-    if (!found) {
-      violations.push({
-        index: i,
-        kind: "orphan_tool_message",
-        toolCallId: id,
-        detail: `tool message at index ${i} is not immediately after its assistant tool_calls`
-      });
-    }
-  }
-  return { ok: violations.length === 0, violations };
-}
-
-// src/hooks/magic-context/lkg-replay.ts
-function canonicalLkgModelKeys(modelKey, providerKey) {
-  const canonicalModelKey = modelKey ? piModelRefToCanonical(modelKey) : null;
-  const slash = canonicalModelKey?.indexOf("/") ?? -1;
-  return {
-    modelKey: canonicalModelKey,
-    providerKey: slash > 0 && canonicalModelKey ? canonicalModelKey.slice(0, slash) : providerKey
-  };
-}
-function resolveLkgModelKeys(messages) {
-  for (let index = messages.length - 1;index >= 0; index -= 1) {
-    const info = messages[index]?.info;
-    const nested = info?.model;
-    if (nested && typeof nested === "object") {
-      const provider = nested.providerID;
-      const model = nested.modelID;
-      if (typeof provider === "string" && typeof model === "string") {
-        return canonicalLkgModelKeys(`${provider}/${model}`, provider);
-      }
-    }
-    const provider = info?.providerID;
-    const model = info?.modelID;
-    if (typeof provider === "string" && typeof model === "string") {
-      return canonicalLkgModelKeys(`${provider}/${model}`, provider);
-    }
-  }
-  return { modelKey: null, providerKey: null };
-}
-function projectLkgEntry(messages) {
-  return projectEntryWithDigests(messages, messages.map(lkgContentDigest));
-}
-function createLkgEntryProjector(options = {}) {
-  const priors = new Map;
-  const maxBytes = options.maxBytes ?? 64 * 1024 * 1024;
-  let bytes = 0;
-  return (sessionId, messages) => {
-    const prior = priors.get(sessionId);
-    const snapshots = messages.map((message) => ({
-      id: typeof message.info?.id === "string" ? message.info.id : "",
-      fields: lkgContentFields(message)
-    }));
-    let reused = 0;
-    const digests = snapshots.map((snapshot) => {
-      const cached = prior?.entries.get(snapshot.id);
-      if (snapshot.fields && cached && exactReusablePrefix([snapshot], [cached.snapshot]) === 1) {
-        reused += 1;
-        return cached.digest;
-      }
-      if (!snapshot.fields)
-        return null;
-      return options.maxBytes === undefined ? memoizedLkgContentDigestFromFields(snapshot.id, snapshot.fields) : lkgContentDigestFromFields(snapshot.fields);
-    });
-    if (prior) {
-      bytes -= prior.bytes;
-      priors.delete(sessionId);
-    }
-    let size = 0;
-    let retainedCount = 0;
-    const retained = new Map;
-    snapshots.forEach((snapshot, index) => {
-      const entrySize = snapshot.id.length * 2 + (snapshot.fields?.reduce((sum, field) => sum + 16 + (typeof field === "string" ? field.length * 2 : 0), 0) ?? 0) + 80 + 86;
-      if (!snapshot.fields || retained.has(snapshot.id) || size + entrySize > maxBytes)
-        return;
-      size += entrySize;
-      retainedCount += 1;
-      retained.set(snapshot.id, {
-        snapshot,
-        digest: digests[index] ?? null
-      });
-    });
-    if (size <= maxBytes && retainedCount > 0) {
-      while (priors.size >= 16 || bytes + size > maxBytes) {
-        const oldest = priors.entries().next().value;
-        if (!oldest)
-          break;
-        bytes -= oldest[1].bytes;
-        priors.delete(oldest[0]);
-      }
-      priors.set(sessionId, {
-        entries: retained,
-        bytes: size
-      });
-      bytes += size;
-    }
-    options.onReuse?.({ reused, retained: retainedCount, retainedBytes: size });
-    return projectEntryWithDigests(messages, digests);
-  };
-}
-function projectEntryWithDigests(messages, digests) {
-  return messages.map((message, index) => {
-    const info = messageInfo(message);
-    const time = info.time;
-    const timeRecord = time && typeof time === "object" ? time : null;
-    const timeCandidates = [
-      timeRecord?.created,
-      info.timeCreated,
-      info.time_created,
-      info.createdAt,
-      info.created_at
-    ];
-    let timeCreated = null;
-    for (const value of timeCandidates) {
-      if (typeof value === "number" && Number.isFinite(value)) {
-        timeCreated = value;
-        break;
-      }
-    }
-    let hasIncompleteTool = false;
-    for (const rawPart of messageParts(message)) {
-      if (!rawPart || typeof rawPart !== "object")
-        continue;
-      const part = rawPart;
-      if (part.type !== "tool" || part.providerExecuted === true)
-        continue;
-      const state = part.state;
-      const status = state && typeof state === "object" ? state.status : undefined;
-      if (status !== "completed") {
-        hasIncompleteTool = true;
-        break;
-      }
-    }
-    const id = info.id;
-    const projection = {
-      id: typeof id === "string" && id.length > 0 ? id : null,
-      role: typeof info.role === "string" ? info.role : undefined,
-      synthetic: info.synthetic === true,
-      timeCreated,
-      finish: info.finish,
-      hasIncompleteTool
-    };
-    const contentDigest = digests[index] ?? null;
-    Object.defineProperty(projection, "contentDigest", {
-      value: () => contentDigest,
-      enumerable: false
-    });
-    return projection;
-  });
-}
-function recordValue(info, key) {
-  return info && typeof info === "object" ? info[key] : undefined;
-}
-function messageInfo(message) {
-  if (message.info && typeof message.info === "object")
-    return message.info;
-  return message;
-}
-function messageParts(message) {
-  return Array.isArray(message.parts) ? message.parts : [];
-}
-function isSynthetic(message) {
-  return recordValue(messageInfo(message), "synthetic") === true;
-}
-function hasSyntheticParts(message) {
-  const parts = messageParts(message);
-  return parts.length > 0 && parts.every((part) => {
-    return Boolean(part && typeof part === "object" && part.synthetic === true);
-  });
-}
-function isSyntheticOutput(message) {
-  return isSynthetic(message) || hasSyntheticParts(message);
-}
-function messageRole(message) {
-  const infoRole = recordValue(messageInfo(message), "role");
-  if (typeof infoRole === "string")
-    return infoRole;
-  const role = recordValue(message, "role");
-  return typeof role === "string" ? role : undefined;
-}
-function messageId(message) {
-  const id = recordValue(messageInfo(message), "id") ?? recordValue(message, "id");
-  return typeof id === "string" && id.length > 0 ? id : null;
-}
-function latestAssistant(messages) {
-  for (let index = messages.length - 1;index >= 0; index -= 1) {
-    if (messages[index].role === "assistant")
-      return messages[index];
-  }
-  return null;
-}
-function isRealUser(message) {
-  return message.role === "user" && !message.synthetic && message.id !== null;
-}
-function assistantIsActive(message) {
-  return message.finish === "tool-calls" || message.hasIncompleteTool;
-}
-function findLkgAnchor(messages) {
-  const assistant = latestAssistant(messages);
-  const assistantTime = assistant?.timeCreated ?? null;
-  if (assistant && assistantTime === null)
-    return null;
-  let anchor = -1;
-  for (let index = messages.length - 1;index >= 0; index -= 1) {
-    const message = messages[index];
-    if (!isRealUser(message))
-      continue;
-    if (assistant && assistantIsActive(assistant)) {
-      if (assistantTime === null || message.timeCreated === null || message.timeCreated <= assistantTime) {
-        continue;
-      }
-    }
-    anchor = index;
-    break;
-  }
-  return anchor >= 0 ? anchor : null;
-}
-function asEntryProjection(input) {
-  if (input.length === 0 || "hasIncompleteTool" in input[0]) {
-    return input;
-  }
-  return projectLkgEntry(input);
-}
-function outputMessageIsPostAnchor(message, inputIndexById, anchorIndex) {
-  const id = messageId(message);
-  if (id !== null) {
-    const inputIndex = inputIndexById.get(id);
-    if (inputIndex !== undefined)
-      return inputIndex > anchorIndex;
-    if (!isSyntheticOutput(message))
-      return null;
-    const linked = ["sourceMessageId", "ownerMessageId", "anchorMessageId", "messageId"].map((key) => recordValue(messageInfo(message), key)).find((value) => typeof value === "string");
-    if (typeof linked === "string") {
-      const linkedIndex = inputIndexById.get(linked);
-      if (linkedIndex === undefined)
-        return null;
-      return linkedIndex > anchorIndex;
-    }
-    return false;
-  }
-  if (!isSyntheticOutput(message))
-    return null;
-  const linked = ["sourceMessageId", "ownerMessageId", "anchorMessageId"].map((key) => recordValue(message.info, key)).find((value) => typeof value === "string");
-  if (typeof linked !== "string")
-    return false;
-  const linkedIndex = inputIndexById.get(linked);
-  return linkedIndex === undefined ? null : linkedIndex > anchorIndex;
-}
-function buildLkgPrefix(input, output) {
-  const projected = asEntryProjection(input);
-  const anchorIndex = findLkgAnchor(projected);
-  if (anchorIndex === null)
-    return null;
-  const ids = projected.map((message) => message.id);
-  if (ids.some((id) => id === null))
-    return null;
-  const validIds = ids;
-  if (new Set(validIds).size !== validIds.length)
-    return null;
-  const anchorMessageId = validIds[anchorIndex];
-  const inputContentDigests = projected.slice(0, anchorIndex + 1).map((message) => message.contentDigest?.() ?? null);
-  if (inputContentDigests.some((digest) => digest === null))
-    return null;
-  const inputIndexById = new Map(validIds.map((id, index) => [id, index]));
-  const prefix = [];
-  for (const message of output) {
-    const postAnchor = outputMessageIsPostAnchor(message, inputIndexById, anchorIndex);
-    if (postAnchor === null)
-      return null;
-    if (!postAnchor)
-      prefix.push(message);
-  }
-  let jsonPrefix;
-  try {
-    jsonPrefix = JSON.stringify(prefix);
-    if (typeof jsonPrefix !== "string")
-      return null;
-  } catch {
-    return null;
-  }
-  return {
-    anchorIndex,
-    anchorMessageId,
-    inputIdSeq: validIds.slice(0, anchorIndex + 1),
-    inputContentDigests,
-    jsonPrefix
-  };
-}
-function captureLkgSlot(args) {
-  const built = buildLkgPrefix(args.input, args.output);
-  if (!built)
-    return false;
-  const modelKeys = canonicalLkgModelKeys(args.modelKey, args.providerKey);
-  const slot = {
-    jsonPrefix: built.jsonPrefix,
-    inputIdSeq: built.inputIdSeq,
-    inputContentDigests: built.inputContentDigests,
-    lastInputMessageId: built.anchorMessageId,
-    modelKey: modelKeys.modelKey,
-    providerKey: modelKeys.providerKey,
-    capturedAt: args.capturedAt ?? Date.now()
-  };
-  const captured = captureSlot(args.sessionId, slot);
-  if (captured)
-    noteCapturedLkgRequest({
-      sessionId: args.sessionId,
-      slot,
-      request: built.anchorIndex === args.input.length - 1 ? claimLkgRequestIdentity(args.sessionId) : undefined,
-      systemPromptTokens: args.systemPromptTokens ?? 0,
-      agentName: args.agentName
-    });
-  return captured;
-}
-function entryIdsAreValid(slot, entryIds) {
-  if (slot.inputIdSeq.length === 0 || entryIds.length < slot.inputIdSeq.length)
-    return false;
-  if (slot.inputIdSeq[slot.inputIdSeq.length - 1] !== slot.lastInputMessageId)
-    return false;
-  const seen = new Set;
-  for (const id of entryIds) {
-    if (!id || seen.has(id))
-      return false;
-    seen.add(id);
-  }
-  if (entryIds.indexOf(slot.lastInputMessageId) !== slot.inputIdSeq.length - 1)
-    return false;
-  for (let index = 0;index < slot.inputIdSeq.length; index += 1) {
-    if (entryIds[index] !== slot.inputIdSeq[index])
-      return false;
-  }
-  return true;
-}
-function entryContentIsValid(slot, entryDigests) {
-  return entryDigests.length >= slot.inputContentDigests.length && slot.inputContentDigests.every((digest, index) => entryDigests[index] === digest);
-}
-function partCallIds(message) {
-  const ids = [];
-  for (const rawPart of messageParts(message)) {
-    if (!rawPart || typeof rawPart !== "object")
-      continue;
-    const part = rawPart;
-    if (part.type !== "tool" && part.type !== "tool_use")
-      continue;
-    const callId = part.callID ?? part.callId ?? part.id;
-    if (typeof callId === "string" && callId.length > 0)
-      ids.push(callId);
-  }
-  return ids;
-}
-function partResultIds(message) {
-  const ids = [];
-  for (const rawPart of messageParts(message)) {
-    if (!rawPart || typeof rawPart !== "object")
-      continue;
-    const part = rawPart;
-    if (part.type !== "tool_result" && part.type !== "tool-result")
-      continue;
-    const callId = part.tool_call_id ?? part.tool_use_id ?? part.callID ?? part.callId;
-    if (typeof callId === "string" && callId.length > 0)
-      ids.push(callId);
-  }
-  return ids;
-}
-function partIsReasoning(part) {
-  return Boolean(part && typeof part === "object" && part.type === "reasoning");
-}
-function partIsAnthropicThinking(part) {
-  if (!part || typeof part !== "object")
-    return false;
-  const type = part.type;
-  return type === "thinking" || type === "reasoning" || type === "redacted_thinking";
-}
-function partEndsAnthropicAssistantRun(part) {
-  if (!part || typeof part !== "object")
-    return false;
-  const value = part;
-  if (value.type !== "tool" || value.providerExecuted === true || !value.state || typeof value.state !== "object") {
-    return false;
-  }
-  const status = value.state.status;
-  return status === "completed" || status === "error";
-}
-function partIsOpenCodeStepMetadata(part) {
-  if (!part || typeof part !== "object")
-    return false;
-  const type = part.type;
-  return type === "step-start" || type === "step-finish";
-}
-function validateAnthropicReasoningRuns(messages) {
-  let index = 0;
-  while (index < messages.length) {
-    if (messageRole(messages[index]) !== "assistant") {
-      index += 1;
-      continue;
-    }
-    let firstMessageInRun = null;
-    let sawOtherContent = false;
-    while (index < messages.length && messageRole(messages[index]) === "assistant") {
-      for (const part of messageParts(messages[index])) {
-        if (partEndsAnthropicAssistantRun(part)) {
-          firstMessageInRun = null;
-          sawOtherContent = false;
-        } else if (!partIsOpenCodeStepMetadata(part)) {
-          if (firstMessageInRun === null)
-            firstMessageInRun = index;
-          if (partIsAnthropicThinking(part)) {
-            if (sawOtherContent || index !== firstMessageInRun)
-              return false;
-          } else {
-            sawOtherContent = true;
-          }
-        }
-      }
-      index += 1;
-    }
-  }
-  return true;
-}
-function validateLkgSeamBoundary(prefix, tail) {
-  const last = prefix[prefix.length - 1];
-  const first = tail[0];
-  if (!last || !first)
-    return true;
-  const lastCalls = partCallIds(last);
-  if (lastCalls.length === 0)
-    return true;
-  const firstCalls = new Set([...partCallIds(first), ...partResultIds(first)]);
-  if (messageRole(first) === "tool" || lastCalls.some((callId) => firstCalls.has(callId)))
-    return false;
-  return !messageParts(last).some((part) => {
-    if (!part || typeof part !== "object")
-      return false;
-    const value = part;
-    if (value.type !== "tool")
-      return false;
-    const state = value.state;
-    return !state || typeof state !== "object" || state.status !== "completed";
-  });
-}
-function validateLkgSeam(prefix, tail, providerKey) {
-  const all = [...prefix, ...tail];
-  const ids = new Set;
-  const calls = new Set;
-  const results = new Set;
-  for (const message of all) {
-    const id = messageId(message);
-    if (id !== null) {
-      if (ids.has(id))
-        return false;
-      ids.add(id);
-    }
-    for (const callId of partCallIds(message)) {
-      if (calls.has(callId))
-        return false;
-      calls.add(callId);
-    }
-    for (const callId of partResultIds(message)) {
-      if (results.has(callId))
-        return false;
-      results.add(callId);
-    }
-    if (messageRole(message) !== "assistant" && messageParts(message).some(partIsReasoning))
-      return false;
-    if (providerKey !== "anthropic" && messageParts(message).some((part) => {
-      if (!part || typeof part !== "object")
-        return false;
-      const value = part;
-      return (value.type === "text" || value.type === "reasoning") && value.text === "";
-    }))
-      return false;
-  }
-  if (!validateLkgSeamBoundary(prefix, tail))
-    return false;
-  const wireCandidates = all.map((message) => message);
-  if (wireCandidates.every((message) => typeof message.role === "string")) {
-    const adjacency = assertOpenAiCompatAdjacency(wireCandidates);
-    if (!adjacency.ok)
-      return false;
-    const wireCallIds = new Set;
-    for (const wireMessage of wireCandidates) {
-      for (const call of wireMessage.tool_calls ?? []) {
-        if (wireCallIds.has(call.id))
-          return false;
-        wireCallIds.add(call.id);
-      }
-    }
-  }
-  return true;
-}
-function replayLkg(args) {
-  const slot = getSlot(args.sessionId);
-  if (!slot)
-    return { ok: false, reason: "lkg_invalidated_reshape" };
-  const requestedModelKeys = canonicalLkgModelKeys(args.modelKey, args.providerKey);
-  const capturedModelKeys = canonicalLkgModelKeys(slot.modelKey, slot.providerKey);
-  if (capturedModelKeys.modelKey !== requestedModelKeys.modelKey || capturedModelKeys.providerKey !== requestedModelKeys.providerKey) {
-    dropSlot(args.sessionId, "lkg_model_mismatch");
-    return { ok: false, reason: "lkg_model_mismatch" };
-  }
-  const entry = args.entry ?? noteEntry(args.sessionId, args.messages);
-  if (!entry || entry.anchorIndex !== slot.inputIdSeq.length - 1 || !entryIdsAreValid(slot, entry.entryInputIds)) {
-    dropSlot(args.sessionId, "lkg_invalidated_reshape");
-    return { ok: false, reason: "lkg_invalidated_reshape" };
-  }
-  if (!entryContentIsValid(slot, entry.entryContentDigests)) {
-    dropSlot(args.sessionId, "lkg_content_mismatch");
-    return { ok: false, reason: "lkg_content_mismatch" };
-  }
-  let prefix;
-  try {
-    const parsed = JSON.parse(slot.jsonPrefix);
-    if (!Array.isArray(parsed))
-      throw new Error("prefix is not an array");
-    prefix = parsed;
-  } catch {
-    dropSlot(args.sessionId, "lkg_seam_invalid");
-    return { ok: false, reason: "lkg_seam_invalid" };
-  }
-  const replayed = [...prefix, ...entry.pristineTail];
-  args.prepareReplay?.(replayed);
-  if (!args.skipSeamValidation) {
-    if (!validateLkgSeamBoundary(prefix, entry.pristineTail)) {
-      dropSlot(args.sessionId, "lkg_unsafe_seam");
-      return { ok: false, reason: "lkg_unsafe_seam" };
-    }
-    if (!validateLkgSeam(prefix, entry.pristineTail, requestedModelKeys.providerKey)) {
-      dropSlot(args.sessionId, "lkg_seam_invalid");
-      return { ok: false, reason: "lkg_seam_invalid" };
-    }
-  }
-  if (requestedModelKeys.providerKey === "anthropic" && !validateAnthropicReasoningRuns(replayed)) {
-    dropSlot(args.sessionId, "lkg_anthropic_reasoning_run_invalid");
-    return { ok: false, reason: "lkg_anthropic_reasoning_run_invalid" };
-  }
-  return { ok: true, messages: replayed };
-}
-
 // src/hooks/magic-context/lkg-replay-fit.ts
 var RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
 function lkgReplayLimit(args) {
@@ -10637,7 +10009,7 @@ class StorageBusyRefusalError extends Error {
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
@@ -10780,8 +10152,160 @@ ${BASE_INTRO(memoryEnabled, temporalAwarenessEnabled)}${cavemanWarning}
 ${SELF_TAG_GUIDANCE}${languageGuidance}`;
 }
 
+// src/hooks/magic-context/system-prompt-dates.ts
+function replaceHostDates(prompt, replace) {
+  const fields = /<(plugin-env|environment|env)>[\s\S]*?<\/\1>|Today's date: [^\r\n<]+/g;
+  return prompt.replace(fields, (block) => block.replace(/(^[\t ]*(?:Date|Today's date):[\t ]*)([^\r\n<]+)/gm, (_line, label, date) => `${label}${replace(date)}`));
+}
+function systemPromptDates(prompt, sticky) {
+  const values = [];
+  replaceHostDates(prompt, (date) => {
+    values.push(date);
+    return date;
+  });
+  const prior = sticky ? JSON.parse(sticky) : [];
+  let index = 0;
+  const stable = replaceHostDates(prompt, (date) => prior[index++] ?? date);
+  return { live: values.length ? JSON.stringify(values) : undefined, stable };
+}
+
+// src/hooks/magic-context/system-date-refresh.ts
+var channels = new WeakMap;
+var outputUpdates = new WeakMap;
+var outputIdentities = new WeakMap;
+var outputRequests = new WeakMap;
+function systemDateTurnId(messages) {
+  const start = activeAnthropicTurnStart(messages, true);
+  if (start === undefined)
+    return;
+  const message = messages[start - 1];
+  const id = message.info?.id ?? message.id;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+function bindSystemDateRequestIdentity(output, identity) {
+  outputIdentities.set(output, identity);
+}
+function systemDateRequestIdentity(output) {
+  return outputIdentities.get(output);
+}
+function bindSystemDateRequest(output, request) {
+  if (request)
+    outputRequests.set(output, request);
+}
+function systemDateRequestForOutput(history, output) {
+  const request = outputRequests.get(output);
+  return state(history, request);
+}
+function bindSystemDateOutput(system, update) {
+  outputUpdates.set(system, update);
+}
+function publishSystemDateOutput(system) {
+  outputUpdates.get(system)?.();
+  outputUpdates.delete(system);
+}
+function registerSystemDateRefresh(history) {
+  if (!channels.has(history))
+    channels.set(history, new Map);
+}
+function hasSystemDateRefresh(history) {
+  return channels.has(history);
+}
+function beginSystemDateRequest(history, sessionId, stage, turnId, identity) {
+  const channel = channels.get(history);
+  if (!channel)
+    return;
+  let requests = channel.get(sessionId);
+  if (!requests)
+    channel.set(sessionId, requests = new Map);
+  let request = identity === undefined ? undefined : requests.get(identity);
+  if (identity === undefined) {
+    const candidates = [...requests.values()].filter((candidate) => !candidate.explicit && !(candidate.systemSeen && candidate.messagesSeen) && (stage === "system-after-messages" || candidate.turnId === turnId));
+    const matching = candidates.filter((candidate) => !candidate.ambiguous && (stage === "messages" ? candidate.systemSeen && !candidate.messagesSeen : candidate.messagesSeen && !candidate.systemSeen));
+    if (turnId !== undefined && candidates.length === 1 && matching.length === 1) {
+      request = matching[0];
+    } else if (candidates.length > 0) {
+      for (const candidate of candidates)
+        candidate.ambiguous = true;
+    }
+  }
+  if (!request) {
+    const sameTurn = [...requests.values()].some((candidate) => !candidate.explicit && !(candidate.systemSeen && candidate.messagesSeen) && (stage === "system-after-messages" || candidate.turnId === turnId));
+    request = {
+      sessionId,
+      identity: identity ?? {},
+      turnId,
+      explicit: identity !== undefined,
+      systemSeen: false,
+      systemDone: false,
+      messagesSeen: false,
+      permitted: 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;
+    if (request.explicit || !request.ambiguous || blocked < 2)
+      requests.set(request.identity, request);
+  }
+  if (stage === "messages")
+    request.messagesSeen = true;
+  else
+    request.systemSeen = true;
+  return request;
+}
+function state(history, request) {
+  if (!request)
+    return;
+  const current = channels.get(history)?.get(request.sessionId)?.get(request.identity);
+  return current === request ? current : undefined;
+}
+function systemDateRefreshPermission(history, request) {
+  const current = state(history, request);
+  return current?.ambiguous ? undefined : current?.permitted;
+}
+function waitForSystemDateRefresh(history, request, apply) {
+  const current = state(history, request);
+  if (!current)
+    return false;
+  current.waiting = apply;
+  return true;
+}
+function retire(history, current) {
+  const unpairable = !current.explicit && current.turnId === undefined;
+  if (!unpairable && (!current.systemDone || current.permitted === undefined))
+    return;
+  if (unpairable) {
+    const apply = current.waiting;
+    current.waiting = undefined;
+    apply?.(false);
+  }
+  const channel = channels.get(history);
+  const requests = channel?.get(current.sessionId);
+  requests?.delete(current.identity);
+  if (requests?.size === 0)
+    channel?.delete(current.sessionId);
+}
+function finishSystemDateRefresh(history, request, permitted) {
+  const current = state(history, request);
+  if (!current)
+    return;
+  current.permitted = current.ambiguous ? false : permitted;
+  const apply = current.waiting;
+  current.waiting = undefined;
+  apply?.(current.permitted);
+  retire(history, current);
+}
+function finishSystemDateHook(history, request) {
+  const current = state(history, request);
+  if (!current)
+    return;
+  current.systemDone = true;
+  retire(history, current);
+}
+function clearSystemDateRefresh(history, sessionId) {
+  channels.get(history)?.delete(sessionId);
+}
+
 // src/hooks/magic-context/system-prompt-hash.ts
-var MMC_MARKER = "## Magic Context";
+var MAGIC_CONTEXT_MARKER = "## Magic Context";
 var SYSTEM_PROMPT_GUIDANCE_SEPARATOR = `
 
 `;
@@ -10793,16 +10317,16 @@ function isInternalOpenCodeAgent(systemPromptContent) {
   return systemPromptContent.includes("You are a title generator. You output ONLY a thread title.") || systemPromptContent.includes("Summarize what was done in this conversation. Write like a pull request description.") || systemPromptContent.includes("You are an anchored context summarization assistant for coding sessions.") || systemPromptContent.includes("You are a context summarization agent. You are given a conversation between a user and an agent.");
 }
 function isMagicContextInternalAgent(systemPromptContent) {
-  return systemPromptContent.includes("You are Historian — the hippocampus of a long-running coding agent.");
+  return systemPromptContent.includes("You are Historian — the hippocampus of a long-running coding agent.") || systemPromptContent.includes("for the magic-context system");
 }
 function createSystemPromptHashHandler(deps) {
   const promptSurfaceRuntime = deps.promptSurfaceRuntime ?? createPromptSurfaceRuntime({
     userConfigDirectory: process.cwd(),
-    warn: (message) => console.warn(`[magic-context] config warning: ${message}`)
+    warn: (message) => log(`[magic-context] config warning: ${message}`)
   });
   const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
-  const handler = async (input, output) => {
+  const processSystemPrompt = async (input, output) => {
     const sessionId = input.sessionID;
     if (!sessionId)
       return;
@@ -10826,6 +10350,10 @@ function createSystemPromptHashHandler(deps) {
       sessionLog(sessionId, "system-prompt-hash skipped (matched system_prompt_injection.skip_signatures)");
       return;
     }
+    const messagesPrepared = deps.consumeMessagesPrepared?.(sessionId) ?? false;
+    const dateRequest = beginSystemDateRequest(deps.historyRefreshSessions, sessionId, messagesPrepared ? "system-after-messages" : "system", input.dateRefreshRequest === undefined && hasSystemDateRefresh(deps.historyRefreshSessions) ? (deps.resolveDateTurnId ?? latestRealUserTurnIdFromOpenCodeDb)(sessionId) : undefined, input.dateRefreshRequest);
+    bindSystemDateRequest(output, dateRequest);
+    const requestMessagesFinal = messagesPrepared || systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest) !== undefined;
     let sessionMetaEarly;
     try {
       sessionMetaEarly = getOrCreateSessionMeta(deps.db, sessionId);
@@ -10850,15 +10378,14 @@ function createSystemPromptHashHandler(deps) {
     const promptSurface = guidanceEpochs.resolve(sessionId, deps.promptSurface, modelKey);
     const fullPrompt = output.system.join(`
 `);
-    if (fullPrompt.length > 0 && !fullPrompt.includes(MMC_MARKER) && !skipGuidanceForDisabledSubagent) {
+    if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER) && !skipGuidanceForDisabledSubagent) {
       const guidance = buildMagicContextSection(null, 0, effectiveCtxReduceEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language, deps.memoryEnabled !== false, promptSurface.preset, promptSurface.primaryOverride);
       output.system[0] = `${output.system[0]}${SYSTEM_PROMPT_GUIDANCE_SEPARATOR}${guidance}`;
       sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession}, subagentReduceMode=${subagentReduceMode})`);
     }
     const isCacheBusting = deps.systemPromptRefreshSessions.has(sessionId);
     const idleCacheExpired = sessionMetaEarly !== undefined && computeHardCacheExpired(sessionMetaEarly.cacheTtl, sessionMetaEarly.lastResponseTime, Date.now());
-    const DATE_PATTERN = /Today's date: .+/;
-    const DATE_PATTERN_ALL = /Today's date: .+/g;
+    const adoptSystemChange = idleCacheExpired || requestMessagesFinal && !isHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId));
     const liveSystemContent = output.system.join(`
 `);
     if (liveSystemContent.length === 0)
@@ -10867,29 +10394,56 @@ function createSystemPromptHashHandler(deps) {
     const hasPersistedHash = previousHash !== "" && previousHash !== "0";
     if (!hasPersistedHash)
       stickyDateBySession.delete(sessionId);
-    const dateElementIndexes = [];
-    let currentDate;
-    for (let i = 0;i < output.system.length; i++) {
-      const match = output.system[i].match(DATE_PATTERN);
-      if (!match)
-        continue;
-      dateElementIndexes.push(i);
-      currentDate ??= match[0];
-    }
     const stickyDate = stickyDateBySession.get(sessionId);
-    const stableCandidate = currentDate && stickyDate && currentDate !== stickyDate ? liveSystemContent.replace(DATE_PATTERN_ALL, stickyDate) : liveSystemContent;
-    const stableCandidateHash = createHash5("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const dates = systemPromptDates(liveSystemContent, stickyDate);
+    const currentDate = dates.live;
+    const stableCandidate = dates.stable;
+    const stableCandidateHash = createHash3("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
-    const dateMayAdvance = isCacheBusting || idleCacheExpired || contentOrPresetChanged;
+    const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
+    let deferredDateRefresh = false;
+    if (currentDate && stickyDate && currentDate !== stickyDate && isCacheBusting && !idleCacheExpired && !contentOrPresetChanged && !requestMessagesFinal) {
+      const liveElements = [...output.system];
+      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted) => {
+        if (!permitted) {
+          deps.systemPromptRefreshSessions.add(sessionId);
+          return;
+        }
+        try {
+          const content = liveElements.join(`
+`);
+          const hash = createHash3("md5").update(promptSurfaceHashMaterial(content, promptSurface.preset)).digest("hex");
+          updateSessionMeta(deps.db, sessionId, {
+            systemPromptHash: hash,
+            cachedM0SystemHash: hash,
+            systemPromptTokens: estimateTokens(content)
+          });
+          stickyDateBySession.set(sessionId, currentDate);
+          output.system.splice(0, output.system.length, ...liveElements);
+          publishSystemDateOutput(output.system);
+          deps.systemPromptRefreshSessions.delete(sessionId);
+          sessionLog(sessionId, `system prompt date updated after prefix rewrite: ${stickyDate} → ${currentDate}`);
+        } catch (error) {
+          deps.systemPromptRefreshSessions.add(sessionId);
+          sessionLog(sessionId, "system prompt date refresh failed (keeping frozen date):", error);
+        }
+      });
+    }
+    const dateMayAdvance = idleCacheExpired || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
     if (currentDate && !stickyDate) {
       stickyDateBySession.set(sessionId, currentDate);
     } else if (currentDate && stickyDate && currentDate !== stickyDate) {
       if (dateMayAdvance) {
         stickyDateBySession.set(sessionId, currentDate);
         sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
-      } else if (dateElementIndexes.length > 0) {
-        for (const index of dateElementIndexes) {
-          output.system[index] = output.system[index].replace(DATE_PATTERN_ALL, stickyDate);
+      } else {
+        let offset = 0;
+        const prior = JSON.parse(stickyDate);
+        for (let index = 0;index < output.system.length; index++) {
+          const element = systemPromptDates(output.system[index]);
+          const count = element.live ? JSON.parse(element.live).length : 0;
+          output.system[index] = systemPromptDates(output.system[index], JSON.stringify(prior.slice(offset, offset + count))).stable;
+          offset += count;
         }
         sessionLog(sessionId, `system prompt date frozen: real=${currentDate}, using=${stickyDate} (defer pass)`);
       }
@@ -10898,17 +10452,20 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash5("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = createHash3("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    recordSystemPromptForRequest(sessionId, currentLkgRequestIdentity(sessionId), currentHash, deps.db, previousHash !== currentHash ? !deps.historyRefreshSessions.has(sessionId) : undefined, deps.historyRefreshSessions, deps.pendingMaterializationSessions);
     if (!sessionMetaEarly) {
       return;
     }
     const sessionMeta = sessionMetaEarly;
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
-      sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : "triggering flush"}`);
-      if (!idleCacheExpired) {
+      sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : requestMessagesFinal ? "adopting on the request whose messages are already final" : "triggering flush"}`);
+      if (!adoptSystemChange) {
         deps.historyRefreshSessions.add(sessionId);
         deps.systemPromptRefreshSessions.add(sessionId);
-        deps.pendingMaterializationSessions.add(sessionId);
+        if (!deps.pendingMaterializationSessions.has(sessionId)) {
+          requestPendingMaterialization(deps.pendingMaterializationSessions, sessionId, "system_hash");
+        }
         deps.lastHeuristicsTurnId.delete(sessionId);
       }
     } else if (previousHash === "" || previousHash === "0") {
@@ -10925,19 +10482,27 @@ function createSystemPromptHashHandler(deps) {
         updateSessionMeta(deps.db, sessionId, {
           systemPromptHash: currentHash,
           systemPromptTokens,
-          cachedM0SystemHash: !hasPersistedHash || idleCacheExpired ? currentHash : undefined
+          cachedM0SystemHash: !hasPersistedHash || adoptSystemChange ? currentHash : undefined
         });
       } catch (error) {
         sessionLog(sessionId, "system prompt meta persist failed (fail-open):", error);
       }
     }
-    if (isCacheBusting) {
+    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true)) {
       deps.systemPromptRefreshSessions.delete(sessionId);
     }
   };
+  const handler = async (input, output) => {
+    try {
+      await processSystemPrompt(input, output);
+    } finally {
+      finishSystemDateHook(deps.historyRefreshSessions, systemDateRequestForOutput(deps.historyRefreshSessions, output));
+    }
+  };
   return {
     handler,
     clearSession: (sessionId) => {
+      clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
         stickyDateBySession,
@@ -11657,12 +11222,8 @@ function markDropLeavesReasoning(db, sessionId) {
 
 // src/hooks/magic-context/reasoning-budget.ts
 function projectOpencodeReasoningBudgetCutoff(db, sessionId, messages, budget, watermark, proseRatio) {
-  const maxTags = new Map;
-  for (const tag of getTagsBySession(db, sessionId)) {
-    const id = tag.type === "tool" ? tag.toolOwnerMessageId : contentTagOwnerMessageId(tag.messageId);
-    if (id)
-      maxTags.set(id, Math.max(maxTags.get(id) ?? 0, tag.tagNumber));
-  }
+  const textEstimateByMessageId = getReasoningTokenEstimatesByMessage(db, sessionId, proseRatio);
+  const maxTags = getMaxTagNumberByOwnerMessage(db, sessionId);
   const messageTags = new Map;
   const gone = new Set(getReasoningRemovalState(db, sessionId).messageIds);
   for (const message of messages) {
@@ -11673,15 +11234,16 @@ function projectOpencodeReasoningBudgetCutoff(db, sessionId, messages, budget, w
     if (tag > 0 && tag <= watermark)
       gone.add(message.info.id);
   }
+  const frozenMergedIds = getMergedReasoningStrippedIds(db, sessionId);
   return opencodeReasoningBudgetCutoff({
     messages,
     messageTagNumbers: messageTags,
     budget,
     alreadyRemoved: gone,
-    textEstimateByMessageId: getReasoningTokenEstimatesByMessage(db, sessionId, proseRatio),
+    textEstimateByMessageId,
     proseRatio,
-    frozenMergedIds: getMergedReasoningStrippedIds(db, sessionId),
-    alsoGone: new Set([...getMergedReasoningStrippedIds(db, sessionId)].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)))
+    frozenMergedIds,
+    alsoGone: new Set([...frozenMergedIds].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)))
   });
 }
 var DEFAULT_KEEP_REASONING_TOKENS = 1e4;
@@ -11769,14 +11331,25 @@ function opencodeReasoningBudgetCutoff(args) {
   const assistants = args.messages.filter((message) => message.info.role === "assistant");
   const newest = assistants.at(-1);
   const exempt = findLatestAssistantReasoningMutationExemptMessage(args.messages);
+  const anthropic = args.anthropic ?? hasAnthropicReasoning(args.messages);
+  const indexOfMessage = new Map;
+  args.messages.forEach((message, index) => {
+    if (!indexOfMessage.has(message))
+      indexOfMessage.set(message, index);
+  });
+  const frozenParts = args.frozenMergedIds ? readFrozenMergedReasoningParts(args.frozenMergedIds) : undefined;
+  const frozenPartMessageIds = frozenParts ? new Set(frozenParts.keys()) : undefined;
   return reasoningBudgetCutoff(assistants.map((message) => ({
     tag: args.messageTagNumbers.get(message) ?? 0,
-    exempt: message === newest || message === exempt || isInActiveAnthropicTurn(args.messages, args.messages.indexOf(message), args.anthropic ?? hasAnthropicReasoning(args.messages)),
+    exempt: message === newest || message === exempt || isInActiveAnthropicTurn(args.messages, indexOfMessage.get(message) ?? -1, anthropic),
     cost: () => {
       const costMessage = { ...message, parts: [...message.parts] };
-      if (args.frozenMergedIds)
+      const id = message.info.id ?? "";
+      if (args.frozenMergedIds && (frozenParts?.has(id) || args.frozenMergedIds.has(id)))
         stripReasoningFromMergedAssistants([costMessage], "anthropic", {
-          frozenMessageIds: args.frozenMergedIds
+          frozenMessageIds: args.frozenMergedIds,
+          frozenParts,
+          frozenPartMessageIds
         });
       const visible = reasoningTextAndOpaque(args.countNeutralized ? costMessage.parts.map(neutralizedReasoningSource) : costMessage.parts);
       if (!visible.hasReasoning && !visible.inlineText)
@@ -12151,6 +11724,7 @@ var PASS_DEGRADATION_EFFECTS = {
   "auto-search-timeout": "served",
   "auto-search-search-failure": "served",
   "auto-search-cas-exhaustion": "served",
+  "auto-search-storage-busy": "served",
   "auto-search-internal-failure": "served",
   "thinking-binding-recovery-persistence-failure": "changes-request",
   "merged-reasoning-strip-persistence-failure": "changes-request",
@@ -12609,15 +12183,22 @@ function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
 function applyNewToolDrop(target, options) {
-  if (!target)
+  if (options.persist && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+    return { result: "incomplete", mode: "full" };
+  }
+  if (!target) {
+    options.persist?.("full");
     return { result: "absent", mode: "full" };
-  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true) {
+  }
+  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.() === true) {
     const strip = target.hasAttachments?.() === true;
+    options.persist?.(strip ? "skeleton_stripped" : "skeleton_real");
     return {
       result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
       mode: strip ? "skeleton_stripped" : "skeleton_real"
     };
   }
+  options.persist?.("full");
   const result = target.drop?.() ?? "absent";
   if (result === "truncated" && target.hasAttachments?.() === true) {
     return { result: target.skeletonStripped?.() ?? "absent", mode: "skeleton_stripped" };
@@ -12628,6 +12209,18 @@ function hasSmallToolInput(target) {
   const bytes = target?.inputStringBytes?.() ?? null;
   return bytes !== null && bytes <= SKELETON_REAL_INPUT_MAX_BYTES;
 }
+function applyPersistedToolDrop(db, sessionId, tagNumber, target, options, afterWrite) {
+  return applyNewToolDrop(target, {
+    ...options,
+    persist: (mode) => {
+      db.transaction(() => {
+        updateTagDropMode(db, sessionId, tagNumber, mode);
+        updateTagStatus(db, sessionId, tagNumber, "dropped");
+        afterWrite?.();
+      }).immediate();
+    }
+  });
+}
 var CACHE_LOSING_FOLD_REASONS = new Set([
   "model_change",
   "system_hash",
@@ -12701,11 +12294,11 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
     diagnostics.reasons[reason] = (diagnostics.reasons[reason] ?? 0) + 1;
   };
   let admitted = false;
-  let startedAt = 0;
   try {
     db.transaction(() => {
       admitted = true;
-      startedAt = performance.now();
+    }).immediate();
+    {
       const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
       const neededTagNumbers = new Set(pendingOps.map((op) => op.tagId));
       for (const op of syntheticPendingOps)
@@ -12764,9 +12357,30 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
           }
         }
         let shouldPersistDrop = false;
+        const persistDrop = (mode) => {
+          let startedAt = 0;
+          try {
+            db.transaction(() => {
+              startedAt = performance.now();
+              if (mode)
+                updateTagDropMode(db, sessionId, pendingOp.tagId, mode);
+              updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
+              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}`);
@@ -12775,11 +12389,11 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
             didMutateMessage = true;
             operationMutated = true;
             onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "edit_marker" });
-            updateTagDropMode(db, sessionId, pendingOp.tagId, strip ? "edit_marker_stripped" : "edit_marker");
             shouldPersistDrop = true;
           } else {
             const { result: dropResult, mode: appliedMode } = applyNewToolDrop(target, {
-              inWindow: skeletonWindow.has(pendingOp.tagId)
+              inWindow: skeletonWindow.has(pendingOp.tagId),
+              persist: persistDrop
             });
             if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
               reject(`drop_${dropResult}`);
@@ -12795,12 +12409,12 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
             } else {
               reject(`drop_${dropResult}`);
             }
-            updateTagDropMode(db, sessionId, pendingOp.tagId, appliedMode);
             shouldPersistDrop = true;
           }
         } else if (target) {
           const replacement = buildReplacementContent(pendingOp.tagId);
           const priorContent = target.getContent?.();
+          persistDrop();
           const changed = target.setContent(replacement);
           if (changed) {
             didMutateMessage = true;
@@ -12817,30 +12431,25 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
           shouldPersistDrop = true;
         } else if (!synthetic) {
           reject("target_absent");
+          persistDrop();
           shouldPersistDrop = true;
         }
         if (!shouldPersistDrop) {
           reject("not_persisted");
           continue;
         }
-        updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
-        if (!synthetic)
-          removePendingOp(db, sessionId, pendingOp.tagId);
         if (operationMutated)
           diagnostics.mutated += 1;
         else
           diagnostics.persistedWithoutMutation += 1;
       }
-    }).immediate();
+    }
   } 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;
-  } finally {
-    if (admitted)
-      logSlowWriteTransaction("apply_pending_operations", startedAt);
   }
   if (diagnostics) {
     onBatchComplete?.(diagnostics);
@@ -13088,6 +12697,7 @@ function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages)
   const messageIds = messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []);
   const ownersKey = JSON.stringify(messageIds);
   const tagsVersion = tagger.getLoadedTagsVersion?.(sessionId, db);
+  const identityRevision = tagger.getLoadedTagIdentityRevision?.(sessionId, db);
   if (tagsVersion === undefined)
     return getInertWhitespaceAssistantTags(db, sessionId, messageIds);
   let bySession = inertWhitespaceCache.get(db);
@@ -13096,10 +12706,10 @@ function getCachedInertWhitespaceAssistantTags(db, sessionId, tagger, messages)
     inertWhitespaceCache.set(db, bySession);
   }
   const cached = bySession.get(sessionId);
-  if (cached?.tagsVersion === tagsVersion && cached.ownersKey === ownersKey)
+  if (cached?.tagsVersion === tagsVersion && cached.identityRevision === identityRevision && cached.ownersKey === ownersKey)
     return cached.tags;
   const tags = getInertWhitespaceAssistantTags(db, sessionId, messageIds);
-  bySession.set(sessionId, { tagsVersion, ownersKey, tags });
+  bySession.set(sessionId, { tagsVersion, identityRevision, ownersKey, tags });
   return tags;
 }
 function makeToolOwnerCacheKey(sessionId, callId) {
@@ -13256,8 +12866,19 @@ function hasRecentAssistantCommit(messages) {
   }
   return false;
 }
-function isVolatileDeepworkTextPart(part) {
-  return isTextPart(part) && isRecord(part) && part.synthetic === true && isRecord(part.metadata) && part.metadata["oh-my-opencode-slim.deepworkGoal"] === true;
+function isVolatileOmoSyntheticTextPart(part) {
+  if (!isTextPart(part) || !isRecord(part))
+    return false;
+  if (part.synthetic !== true)
+    return false;
+  const metadata = part.metadata;
+  if (!isRecord(metadata))
+    return false;
+  for (const [key, value] of Object.entries(metadata)) {
+    if (key.startsWith("oh-my-opencode-slim.") && value === true)
+      return true;
+  }
+  return false;
 }
 function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const protectedThinkingParts = new Set([...options.protectedThinkingMessages ?? []].flatMap((message) => message.parts));
@@ -13315,9 +12936,16 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
     if (message.info.role === "user") {
       precedingThinkingParts = [];
     }
-    if (message.info.role === "user" && message.parts.length === 1 && isVolatileDeepworkTextPart(message.parts[0])) {
+    if (message.info.role === "user" && message.parts.length === 1 && isVolatileOmoSyntheticTextPart(message.parts[0])) {
       continue;
     }
+    if (message.info.role === "user" && messageId !== null) {
+      for (let index = 0;index < message.parts.length; index += 1) {
+        if (isVolatileOmoSyntheticTextPart(message.parts[index])) {
+          tagger.unbindTag(sessionId, `${messageId}:p${index}`);
+        }
+      }
+    }
     const messageThinkingParts = message.parts.filter(isThinkingPart);
     if (messageThinkingParts.length > 0) {
       reasoningByMessage.set(message, messageThinkingParts);
@@ -13379,6 +13007,10 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         ownerByPartKey.set(part, { ownerMsgId, callId: toolObservation.callId });
       }
       if (messageId && isTextPart(part)) {
+        if (message.info.role === "user" && isVolatileOmoSyntheticTextPart(part)) {
+          textOrdinal += 1;
+          continue;
+        }
         const textPart = part;
         const thinkingParts = messageThinkingParts;
         const contentId = `${messageId}:p${partIndex}`;
@@ -13434,7 +13066,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         accAssignTag += performance.now() - _tAssignText;
         const persistedSource = sourceContents.get(tagId);
         if (persistedSource !== undefined) {
-          textPart.text = persistedSource;
+          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource) : persistedSource;
         } else {
           const sourceContent = stripTagPrefix(textPart.text);
           if (sourceContent.trim().length > 0) {
@@ -13724,31 +13356,27 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     if (plan.shouldDrop) {
       const toDrop = new Set(plan.tagNumbers);
       const newestEmergencyTags = recentTags;
-      db.transaction(() => {
-        for (const tag of tags) {
-          if (!toDrop.has(tag.tagNumber))
-            continue;
-          if (tag.status !== "active" || tag.type !== "tool")
-            continue;
-          const target = targets.get(tag.tagNumber);
-          const recent = (emergency.usagePercentage ?? 0) < 95 && newestEmergencyTags.has(tag.tagNumber);
-          const { result, mode } = applyNewToolDrop(target, {
-            inWindow: recent,
-            keepSkeleton: target?.requiresToolArcSkeleton === true
+      for (const tag of tags) {
+        if (!toDrop.has(tag.tagNumber))
+          continue;
+        if (tag.status !== "active" || tag.type !== "tool")
+          continue;
+        const target = targets.get(tag.tagNumber);
+        const recent = (emergency.usagePercentage ?? 0) < 95 && newestEmergencyTags.has(tag.tagNumber);
+        const { result } = applyPersistedToolDrop(db, sessionId, tag.tagNumber, target, {
+          inWindow: recent,
+          keepSkeleton: target?.requiresToolArcSkeleton === true
+        });
+        if (result === "removed" || result === "truncated") {
+          droppedTools++;
+          emergencyDroppedTools++;
+          droppedTokenReductions.push({
+            tagNumber: tag.tagNumber,
+            mode: result === "removed" ? "full" : "truncated"
           });
-          if (result === "removed" || result === "truncated") {
-            updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-            updateTagDropMode(db, sessionId, tag.tagNumber, mode);
-            droppedTools++;
-            emergencyDroppedTools++;
-            droppedTokenReductions.push({
-              tagNumber: tag.tagNumber,
-              mode: result === "removed" ? "full" : "truncated"
-            });
-            emergencyReclaimedTokens += estimateEmergencyDropReclaimTokens(measuredByTag.get(tag.tagNumber) ?? tag);
-          }
+          emergencyReclaimedTokens += estimateEmergencyDropReclaimTokens(measuredByTag.get(tag.tagNumber) ?? tag);
         }
-      }).immediate();
+      }
       sessionLog(sessionId, `emergency tiered drop: ${plan.reason}`);
     } else {
       sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
@@ -13829,35 +13457,33 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
       group.push(tag);
       fingerprintGroups.set(fingerprint, group);
     }
-    db.transaction(() => {
-      for (const [, group] of fingerprintGroups) {
-        if (group.length <= 1)
+    for (const [, group] of fingerprintGroups) {
+      if (group.length <= 1)
+        continue;
+      group.sort((a, b) => a.tagNumber - b.tagNumber);
+      for (let i = 0;i < group.length - 1; i++) {
+        const tag = group[i];
+        if (config.protectedTagNumbers.has(tag.tagNumber))
           continue;
-        group.sort((a, b) => a.tagNumber - b.tagNumber);
-        for (let i = 0;i < group.length - 1; i++) {
-          const tag = group[i];
-          if (config.protectedTagNumbers.has(tag.tagNumber))
-            continue;
-          const target = targets.get(tag.tagNumber);
-          if (protectedTools.has(tag.tagNumber))
-            continue;
-          if (target?.canDrop?.() === false)
-            continue;
-          const { result, mode } = applyNewToolDrop(target, { inWindow: false });
-          if (result === "incomplete")
-            continue;
-          updateTagDropMode(db, sessionId, tag.tagNumber, mode);
-          updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-          if (result === "removed" || result === "truncated") {
-            deduplicatedTools++;
-            droppedTokenReductions.push({
-              tagNumber: tag.tagNumber,
-              mode: result === "removed" ? "full" : "truncated"
-            });
-          }
+        const target = targets.get(tag.tagNumber);
+        if (protectedTools.has(tag.tagNumber))
+          continue;
+        if (target?.canDrop?.() === false)
+          continue;
+        const { result } = applyPersistedToolDrop(db, sessionId, tag.tagNumber, target, {
+          inWindow: false
+        });
+        if (result === "incomplete")
+          continue;
+        if (result === "removed" || result === "truncated") {
+          deduplicatedTools++;
+          droppedTokenReductions.push({
+            tagNumber: tag.tagNumber,
+            mode: result === "removed" ? "full" : "truncated"
+          });
         }
       }
-    }).immediate();
+    }
   }
   if (droppedTools > 0 || deduplicatedTools > 0 || droppedInjections > 0) {
     sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
@@ -13988,6 +13614,7 @@ function postprocessReplaySnapshot(db, sessionId) {
     ...replay,
     staleReduceStrippedIds: new Set(replay.staleReduceStrippedIds),
     processedImageStrippedIds: new Set(replay.processedImageStrippedIds),
+    processedImageMarkers: new Map(replay.processedImageMarkers),
     strippedPlaceholderIds: new Set(replay.strippedPlaceholderIds),
     hiddenSeamPlaceholderIds: new Set(replay.hiddenSeamPlaceholderIds),
     mergedReasoningStrippedIds: new Set(replay.mergedReasoningStrippedIds),
@@ -14044,6 +13671,39 @@ function captureOpencodeReasoningBudgetStatus(sessionId, messages, budget, prefi
     sources.delete(sources.keys().next().value);
 }
 
+// src/hooks/magic-context/strict-thinking-prefix.ts
+function servedPrefixMatches(args) {
+  const heads = args.messages?.slice(0, 2);
+  if (heads?.length !== 2 || args.m0Text == null || args.m1Text == null)
+    return false;
+  const text = (message) => {
+    if (!isRecord(message))
+      return;
+    if (typeof message.content === "string")
+      return message.content;
+    const parts = Array.isArray(message.parts) ? message.parts : message.content;
+    if (!Array.isArray(parts))
+      return;
+    return parts.filter(isRecord).filter((part) => part.type === "text").map((part) => String(part.text ?? "")).join("");
+  };
+  if (text(heads[0]) !== args.m0Text || text(heads[1]) !== args.m1Text)
+    return false;
+  const head = heads[0];
+  if (!isRecord(head))
+    return false;
+  const parts = Array.isArray(head.parts) ? head.parts : head.content;
+  if (!Array.isArray(parts))
+    return !args.muralDataUrl;
+  const images = parts.filter(isRecord).filter((part) => part.type === "image" || part.type === "file");
+  if (!args.muralDataUrl)
+    return images.length === 0;
+  if (images.length !== 1)
+    return false;
+  const image = images[0];
+  const url = typeof image.url === "string" ? image.url : typeof image.data === "string" && typeof image.mimeType === "string" ? `data:${image.mimeType};base64,${image.data}` : undefined;
+  return url === args.muralDataUrl;
+}
+
 // src/hooks/magic-context/supersession-reclaim.ts
 var SUPERSESSION_RECENT_MESSAGE_WINDOW = 20;
 function recentSupersessionOwnerMessageIds(db, sessionId) {
@@ -14147,6 +13807,21 @@ function readFilePath(target) {
   return null;
 }
 
+// src/hooks/magic-context/tag-owner-warmup.ts
+function prewarmTagOwners(db, sessionId, ratio) {
+  if (isTagOwnerSummaryReady(db, sessionId, ratio))
+    return Promise.resolve(true);
+  try {
+    scanTagOwnerSummary(db, sessionId, ratio);
+    return Promise.resolve(true);
+  } catch {
+    return Promise.resolve(false);
+  }
+}
+async function waitForTagOwners(db, sessionId, ratio, _waitMs = 250) {
+  return prewarmTagOwners(db, sessionId, ratio);
+}
+
 // src/hooks/magic-context/tool-reclaim.ts
 function buildSyntheticToolReclaimOps(input) {
   const watermark = Math.max(0, input.watermark);
@@ -14515,6 +14190,9 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
 async function runPostTransformPhase(args) {
   const tPostprocessSetup = performance.now();
   const compactionOff = args.compactionOff === true;
+  if (!compactionOff && !tryGetReasoningTokenEstimatesByMessage(args.db, args.sessionId, sessionDecisionCalibration(args.db, args.sessionId).proseRatio)) {
+    await waitForTagOwners(args.db, args.sessionId, sessionDecisionCalibration(args.db, args.sessionId).proseRatio);
+  }
   const failPass = (site, error = new Error(`Could not complete ${site}`), kind) => {
     args.passOutcome?.record(site, kind);
     if (!compactionOff) {
@@ -14533,8 +14211,9 @@ async function runPostTransformPhase(args) {
   }
   const reasoningMutationExemptMessage = findLatestAssistantReasoningMutationExemptMessage(args.messages);
   const pendingMaterializationAtPassStart = args.pendingMaterializationSessions.has(args.sessionId);
+  const pendingOrigin = pendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId);
   const deferredMaterializationAtPassStart = args.deferredMaterializationSessions.has(args.sessionId);
-  const isExplicitFlush = pendingMaterializationAtPassStart;
+  let isExplicitFlush = pendingMaterializationAtPassStart;
   const deferredMaterializationWasPending = deferredMaterializationAtPassStart;
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
   const forceMaterialization = args.fullFeatureMode && !compactionOff && args.contextUsage.percentage >= args.forceMaterializationPercentage;
@@ -14551,8 +14230,8 @@ async function runPostTransformPhase(args) {
   }
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
-  const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
-  const materializationRequested = isExplicitFlush || deferredMaterialize;
+  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 bindingThinking = new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
@@ -14564,9 +14243,9 @@ async function runPostTransformPhase(args) {
     bindingIds: bindingThinking,
     removedIds: getReasoningRemovalState(args.db, args.sessionId).messageIds
   }) : new Set;
-  const activeThinkingTurn = retainedThinking.size > 0;
+  let activeThinkingTurn = retainedThinking.size > 0;
   const protectedThinkingMessages = new Set(args.messages.filter((message) => message.parts.some((part) => retainedThinking.has(part))));
-  const newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  let newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
   let maxReasoningTag = 0;
   for (const tag of args.messageTagNumbers.values())
     maxReasoningTag = Math.max(maxReasoningTag, tag);
@@ -14576,7 +14255,28 @@ async function runPostTransformPhase(args) {
     if (tag && tag > 0)
       safeReasoningCutoff = Math.min(safeReasoningCutoff, tag - 1);
   }
-  const freezeM0M1 = args.freezeM0M1 === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let activeThinkingPrefixHold = args.activeThinkingPrefixHold === true || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true;
+  let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
+  let rewritingSignedPrefix = false;
+  let thinkingReleasedForFit = false;
+  const releaseThinkingForRewrite = (forFit = false) => {
+    const stripped = freezeReasoningOnBustingPass({
+      db: args.db,
+      sessionId: args.sessionId,
+      messages: args.messages,
+      alreadyFrozen: bindingThinking
+    });
+    if (stripped.persistenceFailed)
+      throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    retainedThinking.clear();
+    protectedThinkingMessages.clear();
+    activeThinkingTurn = false;
+    activeThinkingPrefixHold = false;
+    freezeM0M1 = args.directoryPrefixHold === true;
+    newTargets = args.targets;
+    rewritingSignedPrefix = true;
+    thinkingReleasedForFit ||= forFit;
+  };
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -14594,6 +14294,7 @@ async function runPostTransformPhase(args) {
   const cachedPrefixBeforePreflight = shouldCaptureCachedPrefix ? prepareCachedM0M1Replay(args.db, args.sessionId) : undefined;
   const completeCachedPrefixAvailable = args.sessionMeta.cachedM0Bytes != null && args.sessionMeta.cachedM1Bytes != null || cachedPrefixBeforePreflight !== undefined || m0M1EnabledForFold && !shouldCaptureCachedPrefix && hasCompleteCachedM0M1(args.db, args.sessionId);
   const firstRenderBust = m0M1EnabledForFold && !completeCachedPrefixAvailable;
+  const servedBeforeFirstRender = firstRenderBust ? args.readLastServedMessages?.() : null;
   let foldExecutedThisPass = false;
   let foldBustsServedPrefixThisPass = false;
   let publishedM1RefreshedThisPass = false;
@@ -14609,7 +14310,7 @@ async function runPostTransformPhase(args) {
     m0Bytes: args.sessionMeta.cachedM0Bytes ?? null,
     m1Bytes: args.sessionMeta.cachedM1Bytes ?? null
   };
-  if ((foldDueDecision.value || softRefreshOpportunity) && m0M1EnabledForFold && args.m0M1) {
+  if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
@@ -14632,7 +14333,11 @@ async function runPostTransformPhase(args) {
         onFoldPrepare: () => {
           const conversions = prepareLegacyToolSkeletonConversions(args.db, args.sessionId, args.targets);
           return (db, rendered) => {
-            const bustsPrefix = foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            const bustsPrefix = activeThinkingPrefixHold ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString()
+            }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -14649,6 +14354,9 @@ async function runPostTransformPhase(args) {
         }
       });
       preparedPrefix = foldResult;
+      if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+        releaseThinkingForRewrite();
+      }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
       foldBustsServedPrefixThisPass = foldExecutedThisPass && (committedFoldBustsServedPrefix ?? true);
@@ -14682,18 +14390,33 @@ async function runPostTransformPhase(args) {
     }
     sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${m0MaterializeReason ?? foldDueDecision.reason ?? (foldExecutedThisPass ? "drift" : "soft_refresh")} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
   }
+  if (args.normalizeRecoveryTail && (foldBustsServedPrefixThisPass || firstRenderBust)) {
+    args.normalizeRecoveryTail();
+    args.tags = getTagsBySession(args.db, args.sessionId);
+    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();
+  const frontToolCandidates = args.tags.filter((tag) => tag.type === "tool" && tag.status === "active" && args.targets.get(tag.tagNumber)?.canDrop?.());
+  if (activeThinkingPrefixHold && (args.forceSignedRebuildForFit || args.contextUsage.percentage >= 95 && frontToolCandidates.length > 0 && frontToolCandidates.every((tag) => newTargets.get(tag.tagNumber)?.thinkingRewriteProtected === true))) {
+    releaseThinkingForRewrite(true);
+  }
+  if (activeThinkingPrefixHold) {
+    isExplicitFlush = false;
+    deferredMaterialize = false;
+    materializationRequested = false;
+  }
   const shouldReadPendingOps = !compactionOff && (materializationRequested || publishedM1RefreshedThisPass || args.schedulerDecision === "execute" || forceMaterialization || foldExecutedThisPass || firstRenderBust || compartmentRunning);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
   if (args.schedulerDecision === "execute" && pendingOps.some((op) => newTargets.get(op.tagId)?.thinkingDropProtected))
-    args.pendingMaterializationSessions.add(args.sessionId);
+    requestPendingMaterialization(args.pendingMaterializationSessions, args.sessionId, "thinking_hold");
   const formatPendingOpsDepth = () => {
     const depth = getPendingOpsCount(args.db, args.sessionId);
     return depth === null ? "not loaded (deferred pass)" : String(depth);
   };
-  const idleExpiryRebuild = !freezeM0M1 && args.m0M1?.hardSignals?.cacheExpired === true;
+  const heldIdleExpiryRebuild = activeThinkingPrefixHold && args.m0M1?.hardSignals?.cacheExpired === true;
+  const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
@@ -14701,15 +14424,16 @@ async function runPostTransformPhase(args) {
     explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
     publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
   };
-  const publishedWorkDrainAllowed = !compactionOff && hasReclaimRide(rideSignals);
+  const publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
-  const shouldRunHeuristics = !compactionOff && hasReclaimRide(rideSignals) && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldRunHeuristics = !compactionOff && publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  const canEditWholePrefix = isCacheBustingPass && !activeThinkingPrefixHold;
   const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
     ...args.temporalObservedDecisions ?? [],
     ...getTemporalDecisions(args.db, args.sessionId, args.temporalReplayIds ?? args.temporalCandidates.keys())
   ]) : undefined;
-  const temporalDecisions = args.temporalCandidates && !compactionOff ? isCacheBustingPass ? new Map([
+  const temporalDecisions = args.temporalCandidates && !compactionOff ? canEditWholePrefix ? new Map([
     ...previousTemporalDecisions ?? [],
     ...freezeTemporalDecisions(args.db, args.sessionId, args.temporalCandidates)
   ]) : previousTemporalDecisions : undefined;
@@ -14725,6 +14449,43 @@ async function runPostTransformPhase(args) {
   const removedReasoningIds = new Set;
   let dropLeavesReasoning = false;
   let reasoningRemovalReadable = false;
+  const refreshReasoningRemovalUnion = () => {
+    if (compactionOff)
+      return;
+    try {
+      if (reasoningRemovalEnabled) {
+        const committed = getReasoningRemovalState(args.db, args.sessionId);
+        for (const id of committed.messageIds)
+          removedReasoningIds.add(id);
+        dropLeavesReasoning = committed.dropLeavesReasoning;
+      }
+      const committedWatermark = args.db.prepare("SELECT cleared_reasoning_through_tag AS watermark, last_observed_model_key AS modelKey FROM session_meta WHERE session_id=?").get(args.sessionId);
+      if (committedWatermark && committedWatermark.modelKey === args.sessionMeta.lastObservedModelKey) {
+        args.sessionMeta.clearedReasoningThroughTag = Math.max(args.sessionMeta.clearedReasoningThroughTag, committedWatermark.watermark);
+        if (!prefixBoundModel) {
+          if (canUseEmptySentinels)
+            replayClearedReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.sessionMeta.clearedReasoningThroughTag);
+          replayStrippedInlineThinking(args.messages, args.messageTagNumbers, args.sessionMeta.clearedReasoningThroughTag);
+        }
+      }
+    } catch (error) {
+      failPass("reasoning-removal-read-failure", error);
+      throw new EmergencyFailClosedError("Saved reasoning removals could not be refreshed", {
+        cause: error
+      });
+    }
+  };
+  const replayCommittedVisibleDrops = () => {
+    if (compactionOff)
+      return false;
+    const visible = new Set(args.messages);
+    const targets = new Map([...args.targets].filter(([, target]) => {
+      if (target.mutationParts)
+        return target.mutationParts.some(({ message, part }) => visible.has(message) && message.info.syntheticHead !== true && message.parts.includes(part) && (!isRecord(part) || part.synthetic !== true));
+      return target.message !== undefined && visible.has(target.message) && target.message.info.syntheticHead !== true;
+    }));
+    return applyFlushedStatuses(args.sessionId, args.db, targets);
+  };
   if (reasoningRemovalEnabled) {
     try {
       const state = getReasoningRemovalState(args.db, args.sessionId);
@@ -14740,7 +14501,7 @@ async function runPostTransformPhase(args) {
   }
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
-    const reason = isExplicitFlush ? "explicit_flush" : 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})`;
+    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) {
     sessionLog(args.sessionId, `heuristics WILL NOT RUN — reason=${args.schedulerDeferReason}`);
@@ -14803,7 +14564,7 @@ async function runPostTransformPhase(args) {
   logTransformTiming(args.sessionId, "pp.passDecisions", tPassDecisions, `pendingOps=${pendingOps.length}`);
   try {
     if (shouldApplyPendingOps) {
-      const applyReason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (scheduler=${args.schedulerDecision})`;
+      const applyReason = isExplicitFlush ? `pending_materialization origin=${pendingOrigin}` : deferredMaterialize ? "deferred_materialization" : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (scheduler=${args.schedulerDecision})`;
       sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${formatPendingOpsDepth()}, context=${args.contextUsage.percentage.toFixed(1)}%`);
       const tApply = performance.now();
       pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, new Set([
@@ -14830,7 +14591,7 @@ async function runPostTransformPhase(args) {
         wordRules: args.cavemanTextCompression.wordRules
       } : undefined;
       const heuristicTags = shouldApplyPendingOps ? getActiveTagsBySession(args.db, args.sessionId) : args.tags;
-      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
+      const emergencyRewriteAlreadyPriced = pendingOpsDidMutate || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || args.historyRebuiltThisPass || args.compartmentInjectionRebuiltFromDb || args.rebuiltHistoryFromInitialPrepare;
       if (emergencyDropEligible && emergencyRewriteAlreadyPriced && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
       }
@@ -14892,7 +14653,8 @@ async function runPostTransformPhase(args) {
             bindingStrippedIds.add(messageId);
         }
       }
-      const budgetCutoff = routineCleanupApplied ? Math.min(safeReasoningCutoff, opencodeReasoningBudgetCutoff({
+      const reasoningEstimates = tryGetReasoningTokenEstimatesByMessage(args.db, args.sessionId, sessionDecisionCalibration(args.db, args.sessionId).proseRatio);
+      const budgetCutoff = routineCleanupApplied && !activeThinkingPrefixHold && reasoningEstimates ? Math.min(safeReasoningCutoff, opencodeReasoningBudgetCutoff({
         messages: args.messages,
         messageTagNumbers: args.messageTagNumbers,
         budget: args.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS,
@@ -14902,7 +14664,7 @@ async function runPostTransformPhase(args) {
         proseRatio: sessionDecisionCalibration(args.db, args.sessionId).proseRatio,
         frozenMergedIds: getMergedReasoningStrippedIds(args.db, args.sessionId),
         anthropic: canUseEmptySentinels || prefixBoundModel || hasAnthropicReasoning(args.messages),
-        textEstimateByMessageId: getReasoningTokenEstimatesByMessage(args.db, args.sessionId, sessionDecisionCalibration(args.db, args.sessionId).proseRatio)
+        textEstimateByMessageId: reasoningEstimates
       })) : 0;
       const clearedReasoning = routineCleanupApplied && canUseEmptySentinels && ageLaneAllowed ? clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, budgetCutoff) : 0;
       if (routineCleanupApplied && canUseEmptySentinels) {
@@ -14914,7 +14676,7 @@ async function runPostTransformPhase(args) {
         replayStrippedInlineThinking(args.messages, args.messageTagNumbers, persistedInlineWatermark);
       }
       let removedReasoningMessages = 0;
-      if (routineCleanupApplied && reasoningRemovalSelectable && reasoningRemovalReadable) {
+      if (routineCleanupApplied && !prefixBoundModel && reasoningRemovalSelectable && reasoningRemovalReadable) {
         const newIds = selectReasoningRemovals({
           messages: args.messages,
           messageTagNumbers: args.messageTagNumbers,
@@ -14969,7 +14731,7 @@ async function runPostTransformPhase(args) {
       heuristicOrReasoningEditBesidesTrim = heuristicMutationCount + clearedReasoning + strippedInline > 0;
       droppedCount += clearedReasoning + strippedInline + removedReasoningMessages;
       if (pendingMaterializationAtPassStart && !freezeM0M1 && !pendingOps.some((op) => newTargets.get(op.tagId)?.thinkingDropProtected)) {
-        args.pendingMaterializationSessions.delete(args.sessionId);
+        clearPendingMaterialization(args.pendingMaterializationSessions, args.sessionId);
       }
       if (args.currentTurnId) {
         args.lastHeuristicsTurnId.set(args.sessionId, args.currentTurnId);
@@ -15031,7 +14793,7 @@ async function runPostTransformPhase(args) {
       logTransformTiming(args.sessionId, "toolReclaim.select", tReclaimSelect, `targets=${autoReclaimTargetCount}`);
       if (syntheticPendingOps.length > 0) {
         const tReclaimApply = performance.now();
-        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
+        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
         logTransformTiming(args.sessionId, "toolReclaim.apply", tReclaimApply);
         if (autoReclaimDidMutate) {
           droppedCount += syntheticPendingOps.length;
@@ -15084,7 +14846,7 @@ async function runPostTransformPhase(args) {
       const t8 = performance.now();
       const frozenStaleReduceIds = replaySnapshot.staleReduceStrippedIds;
       const staleReduceResult = dropStaleReduceCalls(args.messages, frozenStaleReduceIds, {
-        detect: isCacheBustingPass,
+        detect: canEditWholePrefix,
         protectedCount: args.protectedCount,
         protectedCallIds: new Set(args.tags.filter((tag) => protectedToolTags.has(tag.tagNumber)).map((tag) => tag.messageId)),
         onFirstApplication: recordFirstApplicationAt
@@ -15098,19 +14860,34 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "transform failed dropping stale mmc_reduce calls:", error);
     }
   }
-  if (canUseEmptySentinels && !compactionOff && replaySnapshot) {
+  if (!compactionOff && replaySnapshot) {
     try {
       const tImg = performance.now();
+      const imageWatermark = canEditWholePrefix ? Math.max(args.watermark, getMaxDroppedTagNumber(args.db, args.sessionId)) : args.watermark;
       const frozenImageIds = replaySnapshot.processedImageStrippedIds;
-      const imageResult = stripProcessedImages(args.messages, frozenImageIds, {
-        detect: isCacheBustingPass && args.watermark > 0,
-        watermark: args.watermark,
+      const frozenMarkers = replaySnapshot.processedImageMarkers;
+      const replacementText = canUseEmptySentinels ? "" : "[image stripped]";
+      stripProcessedImages(args.messages, frozenImageIds, {
+        detect: canEditWholePrefix && imageWatermark > 0,
+        watermark: imageWatermark,
         messageTagNumbers: args.messageTagNumbers,
+        protectedCutoff: args.protectedCutoff,
+        contextPercentage: args.contextUsage.percentage,
+        replacementText,
+        frozenMarkers,
+        protectedMessageIds: new Set([
+          ...args.tags.filter((tag) => protectedToolTags.has(tag.tagNumber)).map((tag) => tag.toolOwnerMessageId ?? tag.messageId)
+        ]),
+        persistNewIds: (ids, markers) => {
+          if (!addProcessedImageStrippedIds(args.db, args.sessionId, ids, markers))
+            return false;
+          const committed = getProcessedImageMarkers(args.db, args.sessionId);
+          for (const id of ids)
+            frozenMarkers.set(id, committed.get(id) ?? replacementText);
+          return true;
+        },
         onFirstApplication: recordFirstApplicationAt
       });
-      if (isCacheBustingPass && imageResult.newlyStrippedIds.length > 0) {
-        addProcessedImageStrippedIds(args.db, args.sessionId, imageResult.newlyStrippedIds);
-      }
       logTransformTiming(args.sessionId, "stripProcessedImages", tImg);
     } catch (error) {
       failPass("image-strip-exception", error);
@@ -15316,7 +15093,7 @@ async function runPostTransformPhase(args) {
       messages: args.messages,
       fullFeatureMode: args.fullFeatureMode,
       compactionOff,
-      isCacheBustingPass,
+      isCacheBustingPass: canEditWholePrefix,
       sessionMeta: args.sessionMeta,
       todowriteAvailability: args.todowriteAvailability,
       client: args.client,
@@ -15382,23 +15159,22 @@ async function runPostTransformPhase(args) {
     autoSearchHintAppendedThisPass = autoSearchCompletedThisPass && countAutoSearchHints(args.db, args.sessionId) !== autoSearchHintsBefore;
     logTransformTiming(args.sessionId, "pp.autoSearchHint", tAutoSearch);
   }
-  if (args.fullFeatureMode && isCacheBustingPass) {
+  if (args.fullFeatureMode && canEditWholePrefix) {
     const visibleIds = new Set;
     for (const message of args.messages) {
       if (typeof message.info?.id === "string") {
         visibleIds.add(message.info.id);
       }
     }
-    const prunedDecisions = pruneAutoSearchHintDecisions(args.db, args.sessionId, visibleIds);
-    if (prunedDecisions > 0) {
-      sessionLog(args.sessionId, `sticky-injection GC: pruned ${prunedDecisions} auto-search decision(s)`);
-    }
+    flushAutoSearchHintDecisionRetirement(args.db, args.sessionId, visibleIds);
   }
-  const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? "explicit_flush" : null);
+  const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? pendingOrigin : null);
   const materialized = m0RematerializedThisPass || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
+  refreshReasoningRemovalUnion();
+  replayCommittedVisibleDrops();
   const dropModeSwitchesThisPass = !canUseEmptySentinels && !dropLeavesReasoning && typeof args.resolvedProviderID === "string" && isCacheBustingPass && reasoningRemovalReadable && args.messages.some((message) => message.info.role === "assistant" && message.parts.some((part) => isNeutralizedReasoningPart(part)));
   let bustedThisPass = firstApplicationEdits.any || firstRenderBust || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
-  const proactiveThinkingStripPermitted = isCacheBustingPass;
+  const proactiveThinkingStripPermitted = isCacheBustingPass && !activeThinkingPrefixHold;
   const tFrozenDecisions = performance.now();
   if (reasoningMutationTargetUnknown) {
     const reasoningCandidates = args.reasoningByMessage.size > 0 ? args.reasoningByMessage.keys() : args.messages;
@@ -15450,7 +15226,7 @@ async function runPostTransformPhase(args) {
           sessionLog(args.sessionId, "thinking binding recovery: persistence failed; leaving the bound blocks intact");
         }
       }
-      if (canUseEmptySentinels && isCacheBustingPass) {
+      if (canUseEmptySentinels && canEditWholePrefix) {
         const candidates = findMergedReasoningStripDecisions(args.messages, args.resolvedProviderID, mergedReasoningStrippedIds, {
           mutationExemptMessage: reasoningMutationExemptMessage,
           protectedMessages: args.protectedThinkingMessages
@@ -15497,7 +15273,7 @@ async function runPostTransformPhase(args) {
     }
   };
   const newestAssistantId = typeof trailingBlankNewestAssistant?.info.id === "string" ? trailingBlankNewestAssistant.info.id : undefined;
-  if (isCacheBustingPass && trailingBlankDecisions.size > 0) {
+  if (canEditWholePrefix && trailingBlankDecisions.size > 0) {
     const visibleMessageIds = new Set(args.messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
     const poisonedKeepIds = [];
     for (const [id, decision] of trailingBlankDecisions) {
@@ -15586,7 +15362,7 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  const prefixEditBesidesReasoningTrim = firstRenderBust || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || dropModeSwitchesThisPass || deferredClearedMarkerRetires || autoSearchHintAppendedThisPass || todoAnchorMovedThisPass || firstApplicationEdits.beforeNewerThinking;
+  const prefixEditBesidesReasoningTrim = firstRenderBust || heldIdleExpiryRebuild || materializationRequested || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully || foldBustsServedPrefixThisPass || publishedM1RefreshedThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass || pendingOpsDidMutate || heuristicOrReasoningEditBesidesTrim || emergency || autoReclaimDidMutateThisPass || convertedToolSkeletonsDidMutate || dropModeSwitchesThisPass || deferredClearedMarkerRetires || autoSearchHintAppendedThisPass || todoAnchorMovedThisPass || firstApplicationEdits.beforeNewerThinking;
   if (!compactionOff && args.thinkingBindingRecoveryEnabledForModel === true && proactiveThinkingStripPermitted && prefixEditBesidesReasoningTrim) {
     const outcome = freezeReasoningOnBustingPass({
       db: args.db,
@@ -15626,7 +15402,7 @@ async function runPostTransformPhase(args) {
   const tFinalRepresentation = performance.now();
   if (temporalDecisions)
     injectTemporalMarkers(args.messages, temporalDecisions);
-  const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID, {
+  const finalizeOptions = {
     prependedMessageCount,
     reasoningMutatedMessages,
     reasoningMutationExemptMessage,
@@ -15637,10 +15413,21 @@ async function runPostTransformPhase(args) {
     trailingBlankDecisions,
     skipMergedReasoningStrip: compactionOff,
     skipTrailingWhitespaceStrip: compactionOff
-  });
+  };
+  const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID, finalizeOptions);
   const removedReasoningParts = reasoningRemovalEnabled ? removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID) : 0;
   const reasoningStatusRatio = sessionDecisionCalibration(args.db, args.sessionId).proseRatio;
   captureOpencodeReasoningBudgetStatus(args.sessionId, args.messages, args.keepReasoningTokens ?? DEFAULT_KEEP_REASONING_TOKENS, prefixBoundModel, reasoningStatusRatio);
+  if (!rewritingSignedPrefix)
+    args.restoreLatestTurnOriginals?.();
+  if (!rewritingSignedPrefix && args.restoreLatestTurnOriginals) {
+    refreshReasoningRemovalUnion();
+    if (replayCommittedVisibleDrops()) {
+      finalizeMessageRepresentation(args.messages, args.resolvedProviderID, finalizeOptions);
+    }
+    if (reasoningRemovalEnabled)
+      removeReasoningParts(args.messages, removedReasoningIds, args.resolvedProviderID);
+  }
   sessionLog(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts} removedReasoningParts=${removedReasoningParts} settledDroppedReasoning=${settledDroppedReasoning}`);
   logTransformTiming(args.sessionId, "finalizeMessageRepresentation", tFinalRepresentation, `clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
   const tTailBaseline = performance.now();
@@ -15739,6 +15526,7 @@ async function runPostTransformPhase(args) {
   logTransformTiming(args.sessionId, "pp.tailGuard", tTailGuard);
   args.restoreLatestTurnOriginals?.();
   return {
+    thinkingReleasedForFit,
     explicitMaterializedSuccessfully,
     deferredMaterializedSuccessfully,
     materialized,
@@ -15764,7 +15552,7 @@ function checkM0MutationDriftAndSignal(args) {
   const currentMaxMutationId = getMaxM0MutationId(args.db, args.sessionId) ?? 0;
   const cachedMaxMutationId = args.cachedM0MaxMutationId ?? 0;
   if (currentMaxMutationId !== cachedMaxMutationId) {
-    args.pendingMaterializationSessions.add(args.sessionId);
+    requestPendingMaterialization(args.pendingMaterializationSessions, args.sessionId, "mutation_drift");
     args.historyRefreshSessions?.add(args.sessionId);
     sessionLog(args.sessionId, `m[0] drift watcher: mutation id changed ${cachedMaxMutationId} → ${currentMaxMutationId}; scheduling next-pass materialization`);
     return true;
@@ -15808,7 +15596,6 @@ class UnresolvedHistoryBoundaryError extends Error {
     this.name = "UnresolvedHistoryBoundaryError";
   }
 }
-
 // src/hooks/magic-context/transform.ts
 var MESSAGE_TOKENS_CACHE_MAX = 100;
 var messageTokensBySession = new BoundedSessionMap(MESSAGE_TOKENS_CACHE_MAX);
@@ -15881,6 +15668,7 @@ function resolveTransformHostSeams(deps) {
   return {
     hostRawMessages: deps.hostRawMessages ?? readRawSessionMessages2,
     hostMessageReconciliationSource: deps.hostMessageReconciliationSource ?? readRawSessionMessages2,
+    hostPrepareRawOrdinals: deps.hostPrepareRawOrdinals ?? prepareRawSessionOrdinals2,
     hostProtectedTailBoundary: deps.hostProtectedTailBoundary ?? resolveOpenCodeProtectedTailBoundary,
     hostModelFallback: deps.hostModelFallback ?? findLastAssistantModelFromOpenCodeDb,
     hostRefusalNotice: deps.hostRefusalNotice ?? sendEmergencyRefusalNotice,
@@ -15888,12 +15676,18 @@ function resolveTransformHostSeams(deps) {
   };
 }
 function createTransform(deps) {
+  registerSystemDateRefresh(deps.historyRefreshSessions);
   const finalWireUsage = createFinalWireUsageTracker();
   const host = resolveTransformHostSeams(deps);
   const loadedSessions = new Set;
+  const prefixHoldLogTurnIds = new Map;
+  const thinkingFitRetries = new Set;
+  const clearSessionLogState = (sessionId) => {
+    prefixHoldLogTurnIds.delete(sessionId);
+  };
   const unmanagedOverWindowSessions = new Set;
-  const deferredHistoryRefreshSessions = deps.deferredHistoryRefreshSessions ?? new Set;
-  const deferredMaterializationSessions = deps.deferredMaterializationSessions ?? new Set;
+  const deferredHistoryRefreshSessions = deps.deferredHistoryRefreshSessions ??= new Set;
+  const deferredMaterializationSessions = deps.deferredMaterializationSessions ??= new Set;
   const maintenanceTail = createMaintenanceTailLauncher({
     db: deps.db,
     getMaintenanceConfig: deps.maintenanceConfig,
@@ -15909,17 +15703,22 @@ 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 passOutcome = createPassOutcome();
     const tSessionId = performance.now();
     const sessionId = findSessionId(messages);
     if (!sessionId) {
       return;
     }
+    deps.onMessagesPassStarted?.(sessionId, messages);
+    const dateRequest = systemDateRequestForOutput(deps.historyRefreshSessions, output) ?? beginSystemDateRequest(deps.historyRefreshSessions, sessionId, "messages", systemDateTurnId(messages), systemDateRequestIdentity(output));
+    bindSystemDateRequest(output, dateRequest);
     const temporalCandidates = deps.experimentalTemporalAwareness ? collectTemporalCandidates(messages) : undefined;
     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 recovery = deps.compactionOff ? {} : readLkgRecoveryPrefix(sessionId, lkgInput, messages, deps.db);
     logTransformTiming(sessionId, "lkg.entryProjection", tLkgEntry, entryReuse ? `reused=${entryReuse.reused} retained=${entryReuse.retained} retainedBytes=${entryReuse.retainedBytes}` : undefined);
     const resolvedSessionId = sessionId;
     const runNotificationParams = (sid) => {
@@ -15929,6 +15728,13 @@ function createTransform(deps) {
     beginLkgPass(sessionId);
     clearOpenCodePendingTransformDecision(sessionId);
     const db = deps.db;
+    try {
+      const tPrepare = performance.now();
+      const ready = await host.hostPrepareRawOrdinals(sessionId);
+      logTransformTiming(sessionId, "rawOrdinals.prepare", tPrepare, `ready=${ready}`);
+    } catch (error) {
+      sessionLog(sessionId, "transform: canonical ordinal warm-up threw:", error);
+    }
     const failPass = (site, error, kind) => {
       passOutcome.record(site, kind);
       if (deps.compactionOff === true)
@@ -16070,20 +15876,30 @@ function createTransform(deps) {
     let restoreLatestTurnOriginals;
     const activeThinkingModel = findLastAssistantModel(messages) ?? deps.liveModelBySession?.get(sessionId);
     let activeThinkingTurn = hasActiveAnthropicThinkingTurn(messages, activeThinkingModel?.providerID, activeThinkingModel?.modelID);
-    let freezeM0M1 = activeThinkingTurn && isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID) || sessionDirectoryFellBack && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null && (() => {
+    const unresolvedDirectoryHold = sessionDirectoryFellBack && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null && (() => {
       try {
         return hasRecordedSessionProjectIdentity(db, sessionId);
       } catch {
         return true;
       }
     })();
-    if (freezeM0M1) {
-      sessionLog(sessionId, "session directory unresolved; replaying the frozen m[0]/m[1] and deferring any rebuild");
+    let activeThinkingPrefixHold = activeThinkingTurn && isPrefixBoundThinkingModel(activeThinkingModel?.providerID, activeThinkingModel?.modelID);
+    let freezeM0M1 = unresolvedDirectoryHold || activeThinkingPrefixHold;
+    if (freezeM0M1 && prefixHoldLogTurnIds.get(sessionId) !== currentTurnId) {
+      prefixHoldLogTurnIds.set(sessionId, currentTurnId);
+      const reason = activeThinkingPrefixHold ? "active thinking turn (prefix-bound model)" : "session directory unresolved";
+      sessionLog(sessionId, `m[0]/m[1] frozen: ${reason}; replaying the frozen prefix and deferring any rebuild`);
     }
     const compartmentDirectory = sessionDirectory;
     const historianRunnable = deps.historianRunnable !== false;
     const canRunCompartments = fullFeatureMode && !compactionOff && historianRunnable && (deps.client !== undefined || deps.hiddenCompletionExecutor !== undefined) && compartmentDirectory.length > 0;
     const fallbackModelId = deps.getFallbackModelId?.(sessionId);
+    if (fullFeatureMode && !compactionOff && historianRunnable) {
+      const tOwners = performance.now();
+      await waitForTagOwners(db, sessionId, sessionDecisionCalibration(db, sessionId).proseRatio);
+      sessionMeta = getOrCreateSessionMeta(db, sessionId);
+      logTransformTiming(sessionId, "tagOwners.prepare", tOwners);
+    }
     const tModelDetect = performance.now();
     const persistedUsageBeforeResets = contextUsagePassSnapshot(sessionMeta).persistedUsage;
     if (deps.liveModelBySession) {
@@ -16201,7 +16017,13 @@ function createTransform(deps) {
     }
     const resolvedProviderID = modelForBudget?.providerID;
     activeThinkingTurn ||= hasActiveAnthropicThinkingTurn(messages, resolvedProviderID, modelForBudget?.modelID);
-    freezeM0M1 ||= activeThinkingTurn && isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID);
+    activeThinkingPrefixHold ||= activeThinkingTurn && isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID);
+    freezeM0M1 ||= activeThinkingPrefixHold;
+    if (freezeM0M1 && prefixHoldLogTurnIds.get(sessionId) !== currentTurnId) {
+      prefixHoldLogTurnIds.set(sessionId, currentTurnId);
+      const reason = activeThinkingPrefixHold ? "active thinking turn (prefix-bound model)" : "session directory unresolved";
+      sessionLog(sessionId, `m[0]/m[1] frozen: ${reason}; replaying the frozen prefix and deferring any rebuild`);
+    }
     const protectedThinkingMessagesForPass = activeThinkingTurn || isAnthropicFamilyRoute(resolvedProviderID, modelForBudget?.modelID) ? latestAssistantTurnMessages(messages) : new Set;
     const canUseEmptySentinels = modelAcceptsEmptyContent(resolvedProviderID);
     const resolvedContextLimit = modelForBudget ? resolveTrustedContextLimit(modelForBudget.providerID, modelForBudget.modelID, {
@@ -16267,7 +16089,7 @@ function createTransform(deps) {
     const schedulerDeferReason = schedulerDecision === "defer" ? "scheduler_defer" : null;
     const historyRefreshExplicitBeforePrepare = !freezeM0M1 && deps.historyRefreshSessions.has(sessionId);
     const deferredHistoryWasPendingAtPassStart = !freezeM0M1 && deferredHistoryRefreshSessions.has(sessionId);
-    const prefixTrimSourceOrder = deferredHistoryWasPendingAtPassStart ? capturePrefixTrimSourceOrder(messages) : undefined;
+    const prefixTrimSourceOrder = capturePrefixTrimSourceOrder(messages);
     const earlyActiveRunBlocksMaterialization = (getActiveCompartmentRun(sessionId) !== undefined || sessionMeta.compartmentInProgress) && contextUsageEarly.percentage < forceMaterializationPercentage;
     const canConsumeDeferredEarly = canConsumeDeferredOnThisPass({
       schedulerDecision,
@@ -16411,8 +16233,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     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 ownerRatio = sessionDecisionCalibration(db, sessionId).proseRatio;
+    prewarmTagOwners(db, sessionId, ownerRatio);
+    const tagOwnersReady = isTagOwnerSummaryReady(db, sessionId, ownerRatio);
     let triggerBoundarySnapshot;
-    if (fullFeatureMode && !compactionOff && historianRunnable && !sessionMeta.compartmentInProgress) {
+    if (fullFeatureMode && !compactionOff && historianRunnable && tagOwnersReady && !sessionMeta.compartmentInProgress) {
       const tTrigger = performance.now();
       try {
         const inMemoryTail = buildTriggerInMemoryTail(db, sessionId, extractInMemoryMessageViews(messages));
@@ -16474,6 +16299,26 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       logTransformTiming(sessionId, "injectTemporalMarkers", tTemporal);
     }
     let taggingSucceeded = false;
+    let recoveryBatch = null;
+    let recoveryNormalized = false;
+    const normalizeRecoveryTail = recovery.prefix ? () => {
+      if (recoveryNormalized)
+        return;
+      const tail = messages.filter((message) => recovery.prefix?.untaggedInputIds.has(message.info.id ?? ""));
+      const tagged = tagMessages(sessionId, tail, deps.tagger, db, {
+        skipPrefixInjection: !ctxReduceCallable,
+        servedMessages: messages,
+        normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText
+      });
+      for (const [number, target] of tagged.targets)
+        targets.set(number, target);
+      for (const [message, parts] of tagged.reasoningByMessage)
+        reasoningByMessage.set(message, parts);
+      for (const [message, number] of tagged.messageTagNumbers)
+        messageTagNumbers.set(message, number);
+      recoveryBatch = tagged.batch;
+      recoveryNormalized = true;
+    } : undefined;
     if (!compactionOff) {
       try {
         const t0 = performance.now();
@@ -16484,18 +16329,24 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         const messagesForTagging = messagesBeforeInitialPrepare && hiddenMessagesAtCompactionSeam.length > 0 ? messagesBeforeInitialPrepare : messages;
         const canAdoptScopedToolSweep = isCacheBusting || canConsumeDeferredEarly;
         const scopedToolSweep = useScopedToolSweep(db, sessionId, canAdoptScopedToolSweep) ? true : createPreAdoptionToolSweepResolver(db, sessionId);
-        const result = tagMessages(sessionId, messagesForTagging, deps.tagger, db, {
+        const result = tagMessages(sessionId, recovery.prefix ? messagesForTagging.filter((message) => !recovery.prefix?.untaggedInputIds.has(message.info.id ?? "")) : messagesForTagging, deps.tagger, db, {
           skipPrefixInjection,
           scopedToolSweep,
           servedMessages: messages,
-          protectedThinkingMessages: protectedThinkingMessagesForPass
+          protectedThinkingMessages: protectedThinkingMessagesForPass,
+          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText
         });
         targets = result.targets;
         if (thinkingRecovery.restore)
           restoreLatestTurnOriginals = captureLatestTurnOriginals(messages);
         reasoningByMessage = result.reasoningByMessage;
         messageTagNumbers = result.messageTagNumbers;
-        batch = result.batch;
+        batch = {
+          finalize: () => {
+            result.batch?.finalize();
+            recoveryBatch?.finalize();
+          }
+        };
         if (resolvedProviderID && !isAnthropicFamilyRoute(resolvedProviderID, modelForBudget?.modelID)) {
           for (const target of targets.values()) {
             if (target.requiresToolArcSkeleton)
@@ -16614,7 +16465,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     sessionMeta = { ...sessionMeta, compartmentInProgress };
     logTransformTiming(sessionId, "compartmentPhase", tCompartmentPhase);
     if (pendingCompartmentInjection?.needsFreshMaterialization) {
-      deps.pendingMaterializationSessions.add(sessionId);
+      requestPendingMaterialization(deps.pendingMaterializationSessions, sessionId, "boundary_repair");
       deferredMaterializationSessions.add(sessionId);
     }
     const hardModel = deps.liveModelBySession?.get(sessionId);
@@ -16708,6 +16559,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const protectedCutoff = protectionWindow.cutoff;
     const tPostProcess = performance.now();
     const postTransformResult = await runPostTransformPhase({
+      normalizeRecoveryTail,
       compactionMarkerStrategy: deps.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy,
       sessionId,
       db,
@@ -16726,7 +16578,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       client: deps.client,
       activeAgent,
       batch,
-      contextUsage,
+      contextUsage: thinkingFitRetries.has(sessionId) ? { ...contextUsage, percentage: Math.max(95, contextUsage.percentage) } : contextUsage,
       usableWindow: resolvedContextLimit ?? 0,
       schedulerDecision,
       schedulerDeferReason,
@@ -16738,6 +16590,17 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       compartmentInProgress,
       historyRefreshExplicitBeforePrepare,
       freezeM0M1,
+      activeThinkingPrefixHold,
+      directoryPrefixHold: unresolvedDirectoryHold,
+      forceSignedRebuildForFit: thinkingFitRetries.has(sessionId) || !!recovery.rebuildReason,
+      readLastServedMessages: () => {
+        const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
+        try {
+          return slot ? JSON.parse(slot.jsonPrefix) : null;
+        } catch {
+          return null;
+        }
+      },
       deferredHistoryWasPendingAtPassStart,
       compartmentInjectionRebuiltFromDb: pendingCompartmentInjection?.rebuiltFromDb === true,
       rebuiltHistoryFromInitialPrepare,
@@ -16789,6 +16652,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         hardSignals: m0HardSignals
       }
     });
+    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));
+      messages.splice(0, messages.length, ...JSON.parse(recovery.prefix.json), ...suffix);
+    }
+    const recoveryReleaseReason = recovery.rebuildReason ?? (recoveryNormalized ? "recovery_tail_normalized" : undefined);
+    if (recoveryReleaseReason)
+      postTransformResult.bustedThisPass = true;
     passOutcome.markFinalized();
     const finalWireTail = describeFinalWireTail(messages);
     let finalWireEstimate;
@@ -16819,6 +16691,21 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       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)) {
+          thinkingFitRetries.add(sessionId);
+          requestPendingMaterialization(deps.pendingMaterializationSessions, sessionId, "fit_retry");
+          messages.splice(0, messages.length, ...originalForThinkingFit);
+          try {
+            await transform({}, output);
+          } finally {
+            thinkingFitRetries.delete(sessionId);
+          }
+          return;
+        }
+        if (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") {
         const untrimmed = finalWireEstimate ?? estimateFinalWireInputTokens({
           messages,
@@ -16933,11 +16820,16 @@ 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}`);
     }
-    if (passOutcome.captureEligible) {
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold || postTransformResult.thinkingReleasedForFit === true);
+    if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
+      recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
+    }
+    if (passOutcome.captureEligible || recovery.prefix || recoveryReleaseReason) {
       const keys = resolveLkgModelKeys(messages);
       const modelKey = modelForBudget ? `${modelForBudget.providerID}/${modelForBudget.modelID}` : keys.modelKey;
       const providerKey = modelForBudget?.providerID ?? keys.providerKey;
       const captured = captureLkgSlot({
+        completeOutput: !!recovery.prefix || !!recoveryReleaseReason || isPrefixBoundThinkingModel(resolvedProviderID, modelForBudget?.modelID),
         sessionId,
         input: lkgInput,
         output: messages,
@@ -16949,13 +16841,37 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       if (captured) {
         const capturedSlot = getInMemorySlot(sessionId);
         if (capturedSlot) {
-          withoutSqliteTransformPass(() => setImmediate(() => saveLkgSlotToDb(db, sessionId, capturedSlot)));
+          const revision = lkgDirtyRevision(sessionId) ?? dirtyLkgRecoveryRevision(sessionId, capturedSlot);
+          const fence = {
+            ownDirtyRevision: revision,
+            requiredRevision: revision && ownsLkgDirtyFence(sessionId, revision) ? revision : undefined,
+            rebuild: !!recoveryReleaseReason,
+            retainDirtyRevision: recovery.prefix && !recoveryReleaseReason ? revision : undefined
+          };
+          withoutSqliteTransformPass(() => setImmediate(() => {
+            if (fence.requiredRevision) {
+              const latest = getInMemorySlot(sessionId);
+              if (!latest || latest.capturedAt !== capturedSlot.capturedAt || latest.jsonPrefix !== capturedSlot.jsonPrefix || latest.lastInputMessageId !== capturedSlot.lastInputMessageId || latest.modelKey !== capturedSlot.modelKey || latest.providerKey !== capturedSlot.providerKey)
+                return;
+            }
+            try {
+              saveLkgSlotToDb(db, sessionId, capturedSlot, undefined, fence);
+            } catch (error) {
+              sessionLog(sessionId, "Last-good deferred publication remains uncertified:", error);
+            }
+          }));
         }
+        noteLkgHealthyPrefix(sessionId, lkgInput, messages, !!recoveryReleaseReason);
       }
-      if (postTransformResult.bustedThisPass && !captured) {
-        dropSlot(sessionId, "lkg_refresh_declined");
+      if (!captured) {
+        if (postTransformResult.bustedThisPass)
+          dropSlot(sessionId, "lkg_refresh_declined");
+        noteUncertifiedNormalLkg(sessionId, invalidateCleanLkgRecoveryFence(sessionId, () => loadPersistedLkgSlot(db, sessionId, true), lkgDirtyRevision(sessionId)));
       }
     } else if (passOutcome.degradations.length > 0) {
+      if (compactionOff) {
+        noteUncertifiedNormalLkg(sessionId, invalidateCleanLkgRecoveryFence(sessionId, () => loadPersistedLkgSlot(db, sessionId, true), lkgDirtyRevision(sessionId)));
+      }
       sessionLog(sessionId, `lkg_capture_declined degradations=${passOutcome.degradations.map((item) => item.site).join(",")}`);
     }
     if (postTransformResult.bustedThisPass || hardCacheExpired) {
@@ -16974,7 +16890,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         droppedTokens: postTransformResult.droppedTokens,
         droppedCount: postTransformResult.droppedCount,
         inputTokens: contextUsage.inputTokens,
-        bustedThisPass: true
+        bustedThisPass: true,
+        lkgFrozenReleaseReason: recoveryReleaseReason
       });
     }
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
@@ -17093,7 +17010,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       sessionLog(sessionId, "memory maintenance launch probe failed (ignored):", error);
     }
   };
-  return transform;
+  return Object.assign(transform, {
+    clearSessionLogState(sessionId) {
+      clearSessionLogState(sessionId);
+    }
+  });
 }
 var HIDDEN_CHILD_AGENT_IDS = new Set([
   HISTORIAN_AGENT,
@@ -18339,7 +18260,7 @@ function registerRpcHandlers(rpcServer, args) {
     return detail;
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-rjjz5f7y.js");
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-s1p37t2g.js");
     const { resolveHistorianModel } = await import("./model-resolution-wazv26n0.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 600000;
     const runConfig = historianRunConfig(config, currentPluginConfigReader(directory)?.poll().effective ?? config);
@@ -18369,8 +18290,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-frmwj9hz.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-rnc4nrsr.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-wrjy3qym.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-cz6ev088.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -18405,7 +18326,7 @@ function registerRpcHandlers(rpcServer, args) {
     const message = executeFlush(db, sessionId);
     liveSessionState.historyRefreshSessions.add(sessionId);
     liveSessionState.systemPromptRefreshSessions.add(sessionId);
-    liveSessionState.pendingMaterializationSessions.add(sessionId);
+    requestPendingMaterialization(liveSessionState.pendingMaterializationSessions, sessionId, "user_flush");
     return { ok: true, message };
   });
   rpcServer.handle("wrapup", async (params) => {
@@ -18419,7 +18340,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await import("./wrapup-orchestrator-yknks3ad.js");
+    const { runManagedWrapup } = await import("./wrapup-orchestrator-bmybc5p5.js");
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -19232,8 +19153,8 @@ var v2CompactionMarkerStrategy = {
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/v2/fold/owner.ts
-import { createHash as createHash6 } from "node:crypto";
-var foldDigest = (value) => createHash6("sha256").update(value).digest("hex");
+import { createHash as createHash4 } from "node:crypto";
+var foldDigest = (value) => createHash4("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -19540,6 +19461,11 @@ function toolStateContent(state) {
 `);
 }
 
+// src/v2/hooks/copied-tag-notation.ts
+function stripCopiedTagNotation(text) {
+  return text.includes("§") ? stripPersistedAssistantText(text) : text;
+}
+
 // src/v2/hooks/payload.ts
 var HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
 var HOST_CONTENT_TYPES = new Set([
@@ -19559,6 +19485,35 @@ function rejectContentPart(message, part, reason) {
   else
     log(text);
 }
+var emptyTextOmissionLogged = new Set;
+function placeCacheHint(content, hint) {
+  if (content.length === 0 || content.some((part) => part.cache !== undefined))
+    return;
+  let lastText = content.length - 1;
+  while (lastText >= 0 && content[lastText]?.type !== "text")
+    lastText -= 1;
+  const index = lastText >= 0 ? lastText : content.length - 1;
+  content[index] = { ...content[index], cache: hint };
+}
+function removeEmptyTextParts(content, rendered, mayRemove) {
+  let hint;
+  let removed = 0;
+  for (let index = content.length - 1;index >= 0; index -= 1) {
+    const part = content[index];
+    if (part?.type !== "text" || part.text !== "" || !mayRemove(part))
+      continue;
+    if (hint === undefined)
+      hint = part.cache;
+    content.splice(index, 1);
+    removed += 1;
+  }
+  if (hint !== undefined) {
+    const target = content.length > 0 ? content : rendered.at(-1)?.content;
+    if (target)
+      placeCacheHint(target, hint);
+  }
+  return removed;
+}
 function isHostInstance(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
@@ -19621,12 +19576,14 @@ function contentValueAttachments(value) {
     ...typeof item.name === "string" ? { filename: item.name } : {}
   }));
 }
-function rebuildFileContent(value, output) {
+function rebuildFileContent(value, output, attachments) {
   if (isDroppedToolOutput(output))
     return { type: "text", value: output };
   const rebuilt = [];
   let placed = false;
   for (const item of value) {
+    if (item?.type === "file" && Array.isArray(attachments) && !attachments.some((attachment) => attachment?.url === item.uri && attachment?.mime === item.mime))
+      continue;
     if (item?.type !== "text") {
       rebuilt.push(item);
       continue;
@@ -19727,6 +19684,8 @@ function adaptPayload(draft, admittedIDs = new Set) {
       if (paired.has(content))
         continue;
       const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
+      if (message.role === "assistant" && part.type === "text" && typeof part.text === "string")
+        part.text = stripCopiedTagNotation(part.text);
       if (message.id && admittedIDs.has(message.id))
         part.synthetic = true;
       parts.push(part);
@@ -19766,12 +19725,17 @@ function adaptPayload(draft, admittedIDs = new Set) {
     commit() {
       let head = 0;
       const rendered = [];
+      const emptyTextGuard = modelAcceptsEmptyContent(draft.model.providerID);
+      const imageOmissions = getEmptyImageParts(messages);
+      let omitted = 0;
+      let emptyTextParts = 0;
       for (const message of messages) {
         const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
         const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
         const content = [];
+        const emptyImages = new Set;
         const following = [];
-        for (const candidate of message.parts) {
+        for (const [partIndex, candidate] of message.parts.entries()) {
           const part = candidate;
           const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
           if (!bridge) {
@@ -19827,7 +19791,10 @@ function adaptPayload(draft, admittedIDs = new Set) {
             }
             const { synthetic: _synthetic, ...clean } = part;
             const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
-            content.push(original ?? clean);
+            const projected = original ?? clean;
+            if (imageOmissions.get(message.info.id ?? "")?.has(partIndex))
+              emptyImages.add(projected);
+            content.push(projected);
             continue;
           }
           const state = part.state;
@@ -19859,7 +19826,7 @@ function adaptPayload(draft, admittedIDs = new Set) {
           if (bridge.result && bridge.resultMessage) {
             const result = {
               ...bridge.result,
-              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
+              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output, state.attachments) : {
                 type: state.status === "error" ? "error" : "text",
                 value: state.output
               }
@@ -19870,7 +19837,8 @@ function adaptPayload(draft, admittedIDs = new Set) {
               following.push({ ...bridge.resultMessage, content: [result] });
           }
         }
-        if (content.length || !original?.content.length) {
+        const guarded = removeEmptyTextParts(content, rendered, (part) => emptyTextGuard || emptyImages.has(part));
+        if (content.length || !original?.content.length && guarded === 0) {
           const value = {
             ...original,
             id,
@@ -19879,9 +19847,16 @@ function adaptPayload(draft, admittedIDs = new Set) {
           };
           const existing = id ? existingHeads.get(id) : undefined;
           rendered.push(existing ? Object.assign(existing, { content }) : value);
+        } else if (emptyTextGuard || guarded > 0) {
+          omitted += 1;
         }
+        emptyTextParts += guarded;
         rendered.push(...following);
       }
+      if (omitted + emptyTextParts > 0 && !emptyTextOmissionLogged.has(draft.sessionID)) {
+        emptyTextOmissionLogged.add(draft.sessionID);
+        sessionLog(draft.sessionID, `v2 payload: left out ${omitted} emptied messages and ${emptyTextParts} empty text parts, ${emptyTextGuard ? "because Anthropic rejects an empty text block" : "to replay frozen image omissions"} (logged once per session)`);
+      }
       draft.messages.splice(0, draft.messages.length, ...rendered);
     }
   };
@@ -21545,13 +21520,28 @@ class DeletedSessionTombstones {
 }
 
 // src/v2/hooks/generate.ts
+function generateReplayAnchor(messages) {
+  let index = messages.length - 1;
+  while (index >= 0 && !messages[index]?.id)
+    index--;
+  if (index < 0)
+    return;
+  const id = messages.at(index)?.id;
+  if (!id)
+    return;
+  return { id, tail: clonePreservingInstances(messages.slice(index + 1)) };
+}
+
 class V2GenerateReplay {
   prefixes = new Map;
   capture(draft, anchor) {
-    if (!anchor)
+    if (!anchor) {
+      this.prefixes.delete(draft.sessionID);
+      sessionLog(draft.sessionID, "generate replay capture skipped: no-anchor");
       return;
+    }
     this.prefixes.set(draft.sessionID, {
-      anchor,
+      anchor: clonePreservingInstances(anchor),
       model: `${draft.model.providerID}/${draft.model.id}`,
       agent: draft.agent,
       system: clonePreservingInstances(draft.system),
@@ -21564,12 +21554,23 @@ class V2GenerateReplay {
   }
   apply(draft) {
     const prefix = this.prefixes.get(draft.sessionID);
-    if (!prefix || prefix.model !== `${draft.model.providerID}/${draft.model.id}` || prefix.agent !== draft.agent)
+    const skip = (reason) => {
+      sessionLog(draft.sessionID, `generate replay apply skipped: ${reason}`);
       return false;
-    const index = draft.messages.findIndex((message) => message.id === prefix.anchor);
+    };
+    if (!prefix)
+      return skip("no-prefix");
+    if (prefix.model !== `${draft.model.providerID}/${draft.model.id}`)
+      return skip("model-mismatch");
+    if (prefix.agent !== draft.agent)
+      return skip("agent-mismatch");
+    const index = draft.messages.findIndex((message) => message.id === prefix.anchor.id);
     if (index < 0)
-      return false;
-    const tail = draft.messages.slice(index + 1);
+      return skip("anchor-not-found");
+    const end = index + 1 + prefix.anchor.tail.length;
+    if (JSON.stringify(draft.messages.slice(index + 1, end)) !== JSON.stringify(prefix.anchor.tail))
+      return skip("anchor-tail-mismatch");
+    const tail = draft.messages.slice(end);
     draft.messages.splice(0, draft.messages.length, ...clonePreservingInstances(prefix.messages), ...tail);
     draft.system.splice(0, draft.system.length, ...clonePreservingInstances(prefix.system));
     draft.tools = clonePreservingInstances(prefix.tools);
@@ -21587,9 +21588,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash7 } from "node:crypto";
-function identity2(slot) {
-  return createHash7("sha256").update(JSON.stringify({
+import { createHash as createHash5 } from "node:crypto";
+function identity(slot) {
+  return createHash5("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -21604,14 +21605,14 @@ class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
   capture(sessionId, slot, input, served) {
     this.systems.set(sessionId, {
-      slot: identity2(slot),
+      slot: identity(slot),
       input: JSON.stringify(input),
       served: structuredClone(served)
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity2(slot) || saved.input !== JSON.stringify(input))
+    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
       return false;
     target.splice(0, target.length, ...structuredClone(saved.served));
     return true;
@@ -22389,6 +22390,24 @@ function createV2RawMessageProvider(reader, sessionID) {
   };
 }
 
+// src/v2/hooks/system-prompt-response.ts
+function bindV2SystemPromptResponse(sessionId, reader) {
+  const request = currentLkgRequestIdentity(sessionId);
+  if (request?.kind !== "v2" || request.responseAfterSequence === undefined)
+    return;
+  const first = reader.assistantSince(sessionId, request.responseAfterSequence)[0];
+  if (!first)
+    return;
+  const createdAt = first.data.time?.created ?? first.time_created;
+  if (typeof createdAt !== "number")
+    return;
+  bindSystemPromptResponse(sessionId, request, {
+    responseId: first.id,
+    createdAt,
+    modelKey: first.data.model?.providerID && first.data.model?.id ? `${first.data.model.providerID}/${first.data.model.id}` : undefined
+  });
+}
+
 // src/v2/hooks/tools.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
 
@@ -22534,7 +22553,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -22758,7 +22777,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord4(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash8("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash6("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   if (!selected)
     return `Tag ${number}'s original text part is no longer in stored history.`;
@@ -22766,6 +22785,56 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   return renderedPart !== null ? renderedPart : `Tag ${number}'s stored text part has no renderable content (empty or structural-only); the requested content was not recovered.`;
 }
 
+// src/tools/ctx-expand/search-archive.ts
+function renderSearchArchive(db, sessionId, start, end, tokenBudget, archiveOnly = false) {
+  return withMessageFtsSessionFilter(db, sessionId, (sessionFirst) => {
+    let rawIds;
+    const rows = db.prepare(sessionFirst ? `SELECT f.message_ordinal AS ordinal, f.message_id AS id, f.role, f.content
+                   FROM message_fts_rowid_map AS m
+                   JOIN message_history_fts AS f ON f.rowid = m.fts_rowid
+                   WHERE m.session_id = ?1 AND m.message_ordinal BETWEEN ?2 AND ?3
+                     AND f.session_id = ?1 AND f.message_ordinal BETWEEN ?2 AND ?3
+                   ORDER BY m.message_ordinal` : `SELECT message_ordinal AS ordinal, message_id AS id, role, content
+                   FROM message_history_fts
+                   WHERE session_id = ?1 AND message_ordinal BETWEEN ?2 AND ?3
+                   ORDER BY CAST(message_ordinal AS INTEGER)`);
+    const blocks = [];
+    let tokens = 0;
+    let lastOrdinal = start - 1;
+    let truncated = false;
+    for (const row of rows.iterate(sessionId, start, end)) {
+      if (!row.content)
+        continue;
+      if (!archiveOnly) {
+        rawIds ??= readRawSessionMessageIdOrdinalsForRange2(sessionId, start, end);
+        if (rawIds.get(row.id) === row.ordinal)
+          continue;
+      }
+      const block = `[${row.ordinal}] ${row.role === "user" ? "U" : "A"}: ${row.content}`;
+      const cost = estimateTokens(block);
+      if (blocks.length > 0 && tokens + cost > tokenBudget) {
+        truncated = true;
+        break;
+      }
+      blocks.push(block);
+      tokens += cost;
+      lastOrdinal = row.ordinal;
+    }
+    if (blocks.length === 0)
+      return null;
+    const text = [
+      "From the search archive: indexed text only; no surrounding messages or tool output.",
+      "",
+      ...blocks
+    ];
+    if (truncated) {
+      text.push("", `Truncated at message ${lastOrdinal} (budget: ~${tokenBudget} tokens). Call mmc_expand(start=${lastOrdinal + 1}, end=${end}) for more archived text.`);
+    }
+    return text.join(`
+`);
+  });
+}
+
 // src/tools/ctx-expand/tools.ts
 var ctxExpandArgsShape = {
   tag: tool.schema.union([tool.schema.number(), tool.schema.string()]).optional().describe("Tag number from a §N§ tag or a [dropped §N§] placeholder, not a message ordinal. Returns that one item in full. Use alone."),
@@ -22789,6 +22858,8 @@ function createCtxExpandTool(deps) {
         message: "number"
       });
       const sessionId = toolContext.sessionID;
+      if (!await prepareRawSessionOrdinals2(sessionId))
+        return "Session ordinals are warming in the background. Retry mmc_expand shortly; no approximate ordinal was served.";
       try {
         const mode = resolveCtxExpandMode(args, "positive");
         if (mode.kind === "error") {
@@ -22798,7 +22869,7 @@ function createCtxExpandTool(deps) {
           return renderItemByTag(deps.db, sessionId, mode.tag);
         }
         if (mode.kind === "message") {
-          return renderMessageByOrdinal(sessionId, mode.message);
+          return renderSearchArchive(deps.db, sessionId, mode.message, mode.message, CTX_EXPAND_TOKEN_BUDGET) ?? renderMessageByOrdinal(sessionId, mode.message);
         }
         const { start, end, verbose } = mode;
         const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
@@ -22806,6 +22877,9 @@ function createCtxExpandTool(deps) {
           return `Range ${start}-${end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
         }
         const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(end, lastCompartmentEnd) : end;
+        const archived = renderSearchArchive(deps.db, sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
+        if (archived)
+          return archived;
         if (verbose) {
           const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET, deps.expandTools);
           if (!v.text) {
@@ -23596,9 +23670,15 @@ Stamp: file reads, search results and tool outputs the work ahead no longer need
 Keep: user messages (never stamp one for its directive), your own conversation text, unresolved errors, raw evidence you haven't extracted yet, and outputs whose exact wording may still matter.
 
 Look at each tag before stamping it; never blanket-stamp a range like "1-50". Many small targeted stamps beat one sweep. \`drop\` accepts "3-5", "1,2,9", "1-5,8,12-15".`;
-var CTX_REDUCE_SELF_STAMP_MESSAGE_TEMPLATE = "§N§ is an mmc_reduce call; leave those alone, they are cleaned up automatically.";
-function ctxReduceSelfStampMessage(tagNumber) {
-  return CTX_REDUCE_SELF_STAMP_MESSAGE_TEMPLATE.replace("§N§", `§${tagNumber}§`);
+function formatCtxReduceReply(stampedCount, selfStampCount = 0) {
+  const parts = [];
+  if (stampedCount > 0) {
+    parts.push(`${stampedCount} tag${stampedCount === 1 ? "" : "s"} stamped.`);
+  }
+  if (selfStampCount > 0) {
+    parts.push(selfStampCount === 1 ? "1 was a ctx_reduce call; leave those alone, they are cleaned up automatically." : `${selfStampCount} were ctx_reduce calls; leave those alone, they are cleaned up automatically.`);
+  }
+  return parts.join(" ");
 }
 // src/tools/ctx-reduce/tools.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
@@ -23681,22 +23761,10 @@ function createCtxReduceTool(deps) {
         return `Error: Unknown tag(s) ${formatIds(unknownIds)}. Check available tags in conversation.`;
       }
       const ctxReduceSelfStampIds = new Set(allTags.filter((tag) => tag.toolName?.toLowerCase() === "mmc_reduce").map((tag) => tag.tagNumber));
-      const ctxReduceSelfStampNote = dropIds.filter((id) => ctxReduceSelfStampIds.has(id)).filter((id, index, ids) => ids.indexOf(id) === index).map(ctxReduceSelfStampMessage).join(" ");
+      const ctxReduceSelfStampCount = new Set(dropIds.filter((id) => ctxReduceSelfStampIds.has(id))).size;
       dropIds = dropIds.filter((id) => !ctxReduceSelfStampIds.has(id));
-      let protectedSet;
-      if (deps.protectedSet) {
-        protectedSet = typeof deps.protectedSet === "function" ? deps.protectedSet(sessionId) : deps.protectedSet;
-      } else if (deps.getProtectionWindow) {
-        protectedSet = deps.getProtectionWindow(sessionId).protectedTagNumbers;
-      } else {
-        protectedSet = getProtectionWindowForSession(deps.db, sessionId, deps.floor).protectedTagNumbers;
-      }
       const tagStatusMap = new Map(allTags.map((tag) => [tag.tagNumber, tag.status]));
-      protectedSet = new Set([
-        ...protectedSet,
-        ...protectedToolTagNumbers(getActiveTagsBySession(deps.db, sessionId), deps.protectedTools)
-      ]);
-      const inertWhitespaceTagNumbers = new Set(getInertWhitespaceAssistantTags(deps.db, sessionId).map((tag) => tag.tagNumber));
+      const inertWhitespaceTagNumbers = new Set(getInertWhitespaceAssistantTagsByNumbers(deps.db, sessionId, dropIds).map((tag) => tag.tagNumber));
       const inertDropIds = [
         ...new Set(dropIds.filter((id) => inertWhitespaceTagNumbers.has(id)))
       ];
@@ -23712,15 +23780,15 @@ function createCtxReduceTool(deps) {
       if (conflicts.length > 0) {
         return `Error: Conflicting operations — ${conflicts.join("; ")}.`;
       }
-      const preFilterDropCount = dropIds.length;
+      const stampedCount = new Set(dropIds.filter((id) => !inertWhitespaceTagNumbers.has(id))).size;
       dropIds = dropIds.filter((id) => !inertWhitespaceTagNumbers.has(id) && tagStatusMap.get(id) !== "dropped" && pendingMap.get(id) !== "drop");
-      const skippedCount = preFilterDropCount - dropIds.length;
       if (dropIds.length === 0) {
-        const noActionNotes = [ctxReduceSelfStampNote, inertNote].filter(Boolean);
-        if (!ctxReduceSelfStampNote) {
-          noActionNotes.push("All requested tags were already queued or processed. No new action is needed.");
-        }
-        return noActionNotes.join(" ");
+        const reply = formatCtxReduceReply(stampedCount, ctxReduceSelfStampCount);
+        if (reply)
+          return `${reply}${inertNote ? ` ${inertNote}` : ""}`;
+        if (inertNote)
+          return inertNote;
+        return "All requested tags were already queued or processed. No new action is needed.";
       }
       try {
         deps.db.transaction(() => {
@@ -23735,25 +23803,8 @@ function createCtxReduceTool(deps) {
       }
       const currentInputTokens = deps.getSessionTokens?.(sessionId) ?? getOrCreateSessionMeta(deps.db, sessionId).lastInputTokens;
       updateSessionMeta(deps.db, sessionId, { lastNudgeTokens: currentInputTokens });
-      const immediateDropIds = dropIds.filter((id) => !protectedSet.has(id));
-      const deferredDropIds = [...new Set(dropIds.filter((id) => protectedSet.has(id)))];
-      const skippedNote = skippedCount > 0 ? ` ${skippedCount} requested tag${skippedCount === 1 ? " was" : "s were"} already queued and need no action.` : "";
-      let heldSentence = "";
-      if (deferredDropIds.length === 1) {
-        heldSentence = `Held: §${deferredDropIds[0]} is inside the protected working set; it applies once newer work displaces it.`;
-      } else if (deferredDropIds.length > 1) {
-        heldSentence = `Held: ${deferredDropIds.map((id) => `§${id}`).join(", ")} are inside the protected working set; they apply once newer work displaces them.`;
-      }
-      if (immediateDropIds.length > 0 && heldSentence.length > 0) {
-        return `Queued: drop ${formatIds(immediateDropIds)}.${skippedNote}${inertNote ? ` ${inertNote}` : ""} ${heldSentence}${ctxReduceSelfStampNote ? ` ${ctxReduceSelfStampNote}` : ""}`;
-      }
-      if (immediateDropIds.length > 0) {
-        return `Queued: drop ${formatIds(immediateDropIds)}.${skippedNote}${inertNote ? ` ${inertNote}` : ""}${ctxReduceSelfStampNote ? ` ${ctxReduceSelfStampNote}` : ""}`;
-      }
-      if (heldSentence.length > 0) {
-        return `${heldSentence}${skippedNote}${inertNote ? ` ${inertNote}` : ""}${ctxReduceSelfStampNote ? ` ${ctxReduceSelfStampNote}` : ""}`;
-      }
-      return `Queued: drop ${formatIds(dropIds)}.${skippedNote}${inertNote ? ` ${inertNote}` : ""}${ctxReduceSelfStampNote ? ` ${ctxReduceSelfStampNote}` : ""}`;
+      const reply = formatCtxReduceReply(stampedCount, ctxReduceSelfStampCount);
+      return `${reply}${inertNote ? ` ${inertNote}` : ""}`;
     }
   });
 }
@@ -24126,8 +24177,16 @@ async function applyV2SystemPrompt(systemPrompt, draft) {
     }
   })));
   const system = { system: draft.system.map((part) => String(part.text ?? "")) };
+  bindSystemDateOutput(system.system, () => {
+    draft.system.splice(0, draft.system.length, ...system.system.map((text, index) => ({
+      ...draft.system[index],
+      type: "text",
+      text
+    })));
+  });
   await systemPrompt.handler({
     sessionID: draft.sessionID,
+    dateRefreshRequest: draft,
     model: { providerID: draft.model.providerID, modelID: draft.model.id }
   }, system);
   const originals = [...draft.system];
@@ -24147,6 +24206,7 @@ function createHostSeams(context, readAllForConversion, reconciliationSource, li
   return {
     hostRawMessages: readAllForConversion,
     hostMessageReconciliationSource: reconciliationSource,
+    hostPrepareRawOrdinals: async () => true,
     hostProtectedTailBoundary: (args) => resolveOpenCodeProtectedTailBoundary({
       ...args,
       cacheNamespace: `opencode2:${args.sessionId}`
@@ -24445,6 +24505,7 @@ async function registerContext(context) {
   const sessionDirectories = new Map;
   const forkSeedSettled = new Set;
   const historyRefreshSessions = new Set;
+  registerSystemDateRefresh(historyRefreshSessions);
   const pendingMaterializationSessions = new Set;
   const lastHeuristicsTurnId = new Map;
   const restoredRows = new RestoredRowCache;
@@ -24529,6 +24590,11 @@ async function registerContext(context) {
       try {
         const latest = reader.latestAssistant(draft.sessionID);
         latestLkgResponseIds.set(draft.sessionID, latest?.id);
+        try {
+          bindV2SystemPromptResponse(draft.sessionID, reader);
+        } catch (error) {
+          sessionLog(draft.sessionID, "v2 response ownership unavailable; keeping system identity pending", error);
+        }
         if (latest)
           noteLkgProviderResponse({
             sessionId: draft.sessionID,
@@ -24621,6 +24687,10 @@ async function registerContext(context) {
           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)
@@ -24642,7 +24712,9 @@ async function registerContext(context) {
           continue;
         }
         if (event.type === "session.deleted") {
+          clearLkgMeasuredRequest(sessionID);
           deletedSessions.add(sessionID);
+          transform?.clearSessionLogState(sessionID);
           if (db) {
             markSessionCleanupPending(db, sessionID);
             clearSession(db, sessionID);
@@ -24657,7 +24729,7 @@ async function registerContext(context) {
           agents.delete(sessionID);
           channel1.delete(sessionID);
           historyRefreshSessions.delete(sessionID);
-          pendingMaterializationSessions.delete(sessionID);
+          clearPendingMaterialization(pendingMaterializationSessions, sessionID);
           lastHeuristicsTurnId.delete(sessionID);
           restoredRows.forget(sessionID);
           await nativeFoldReplay?.forget(sessionID);
@@ -24766,6 +24838,7 @@ async function registerContext(context) {
     const systemAtEntry = structuredClone(draft.system);
     const slotAtEntry = getSlot(draft.sessionID);
     const restoreLkgSystem = () => {
+      retirePendingSystemPromptDelivery(draft.sessionID);
       if (!lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), systemAtEntry, draft.system)) {
         sessionLog(draft.sessionID, "lkg_system_state_mismatch");
         throw new Error("LKG system identity is unavailable or changed");
@@ -24917,6 +24990,18 @@ async function registerContext(context) {
         injectionEnabled: config.system_prompt_injection.enabled,
         injectionSkipSignatures: config.system_prompt_injection.skip_signatures
       });
+      let responseAfterSequence;
+      try {
+        const responseReader = openStoreReader();
+        try {
+          responseAfterSequence = responseReader.latestSequence(draft.sessionID);
+        } finally {
+          responseReader.close();
+        }
+      } catch (error) {
+        sessionLog(draft.sessionID, "v2 response boundary unavailable; no system delivery acknowledgement", error);
+      }
+      beginV2LkgRequest(draft.sessionID, `${draft.model.providerID}/${draft.model.id}`, latestLkgResponseIds.get(draft.sessionID), responseAfterSequence);
       const system = await applyV2SystemPrompt(systemPrompt, draft);
       noteMaintenanceSystemSnapshot(draft.sessionID, system.join(`
 `));
@@ -24941,6 +25026,16 @@ async function registerContext(context) {
       await cacheV2SessionDirectory(context.session, draft.sessionID, sessionDirectories);
       if (!rawProviders.has(draft.sessionID))
         rawProviders.set(draft.sessionID, setBoundedRawMessageProvider2(draft.sessionID, createV2RawMessageProvider(pagedRead, draft.sessionID)));
+      const indexDatabase = db;
+      if (indexDatabase) {
+        withoutSqliteTransformPass(() => {
+          try {
+            scheduleReconciliationCatchup(indexDatabase, draft.sessionID, pagedRead);
+          } catch (error) {
+            sessionLog(draft.sessionID, "message index catchup scheduling failed:", error);
+          }
+        });
+      }
       transform ??= createTransform({
         cacheTtlConfig: config.cache_ttl,
         cacheTtlConfigured: config.cacheTtlConfigured,
@@ -24951,6 +25046,7 @@ async function registerContext(context) {
         contextUsageMap: usage,
         compactionOff,
         storeGeneration: "v2",
+        normalizeRestoredAssistantText: stripCopiedTagNotation,
         hostCleanupCompactionMarkers: () => ({
           verified: true,
           removedLineages: 0,
@@ -25009,7 +25105,7 @@ async function registerContext(context) {
         const boundaryRepair = db && !compactionOff ? checkHistoryBoundary(db, reader, draft.sessionID) : undefined;
         if (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset") {
           historyRefreshSessions.add(draft.sessionID);
-          pendingMaterializationSessions.add(draft.sessionID);
+          requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "boundary_repair");
         }
         const incoming = cut && draft.messages.find((message) => message.id === cut.id);
         postFold = cut !== undefined;
@@ -25027,7 +25123,7 @@ async function registerContext(context) {
         }
         if (nativeRestored && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
           historyRefreshSessions.add(draft.sessionID);
-          pendingMaterializationSessions.add(draft.sessionID);
+          requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_history_change");
         }
         if (cut && incoming && nativeRestored) {
           const present = new Set(draft.messages.flatMap((message) => message.id ? [message.id] : []));
@@ -25045,7 +25141,7 @@ async function registerContext(context) {
             onHard: (reason) => {
               log(`[magic-context] HARD reason=${reason} session=${draft.sessionID}`);
               materialize(draft);
-              pendingMaterializationSessions.add(draft.sessionID);
+              requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
             }
           });
           checkpoint = structuredClone(identity.rendered ?? incoming);
@@ -25072,7 +25168,7 @@ async function registerContext(context) {
         }
       }
       const mapped = adaptPayload(draft, admitted);
-      beginV2LkgRequest(draft.sessionID, `${draft.model.providerID}/${draft.model.id}`, latestLkgResponseIds.get(draft.sessionID));
+      bindSystemDateRequestIdentity(mapped, draft);
       await transform({}, mapped);
       mapped.commit();
       if (db) {
@@ -25235,10 +25331,12 @@ ${baseline}
         throw new V2ContextRefusal(STORAGE_BUSY_MESSAGE, { cause: refusal });
       }
     }
-    const anchor = draft.messages.at(-1)?.id;
+    const anchor = generateReplayAnchor(draft.messages);
     await runManagedContext(draft);
-    if (!compactionOff && draft.messages.some((message) => message.id === HEAD_IDS[0] || message.content.some((part) => typeof part.text === "string" && part.text.includes("<session-history>"))))
+    if (!compactionOff)
       generateReplay.capture(draft, anchor);
+    else
+      sessionLog(draft.sessionID, "generate replay capture skipped: compaction-disabled");
   }));
   await context.session.hook("generate", async (draft) => {
     if (!compactionOff && !deletedSessions.has(draft.sessionID))