@cortexkit/opencode-magic-context 0.49.19 → 0.49.21

package/dist/v2/{context-y5yamxak.js → context-ea3x7smm.js}

@@ -6,7 +6,7 @@ import {
   resolveLegacyConfigSources,
   getProtectedTokensTierOverrides,
   loadPluginConfigDetailed
-} from "./server-nj659894.js";
+} from "./server-94wk1ey3.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -21,7 +21,7 @@ import {
   log2,
   sessionLog2,
   getLoggerDiagnostics2
-} from "./server-f2xf5gcb.js";
+} from "./server-6495nmn9.js";
 import {
   hasTrustedAbsoluteWall,
   applyProvenInputFloor,
@@ -33,7 +33,7 @@ import {
   getSdkContextLimit,
   getSdkOutputLimit,
   getModelsDevCacheState
-} from "./server-tbe1femw.js";
+} from "./server-29qp8nz4.js";
 import {
   isValidLanguageCode,
   withContentLanguageDirective,
@@ -46,7 +46,7 @@ import {
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   DEFAULT_LOCAL_EMBEDDING_MODEL,
   DREAM_TASK_PROMOTION_DEFAULTS
-} from "./server-271qxsf5.js";
+} from "./server-24g8r2d0.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -64,7 +64,7 @@ import {
   userMemoryCollectionEnabled2,
   userObservationCollectionEnabled2,
   userObservationsRequested2
-} from "./server-qd11g795.js";
+} from "./server-92g7d776.js";
 import {
   historianRunConfig,
   dreamerRunConfig,
@@ -205,11 +205,15 @@ import {
   parseProviderModel,
   modelBodyField,
   toModelEntry,
+  ModelProducedNoOutputError,
+  noteModelActivityMonitored,
+  noteModelOutputReceived,
   isPromptTimeoutError,
   getPromptFailureDetail,
   raceWithSignal,
   promptSyncWithValidatedOutputRetry,
   normalizeSDKResponse,
+  annotateSubagentInvocationError,
   failedInvocationStatus,
   sumTokensFromChildMessages,
   recordChildInvocation,
@@ -282,10 +286,10 @@ import {
   startCompartmentAgent,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-6vdzn1td.js";
+} from "./server-zg5y109h.js";
 import {
   resolveHistorianModel2
-} from "./server-8cd2j99z.js";
+} from "./server-5kym00ag.js";
 import {
   formatFailClosedBlockingMessage,
   formatFailClosedBlockingSummary,
@@ -307,7 +311,7 @@ import {
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./server-bmymkx73.js";
+} from "./server-j8h7bsca.js";
 import {
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
@@ -324,14 +328,197 @@ import {
   storedPathBelongsToIdentity,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./server-rmygf5pn.js";
+} from "./server-qjvk4a9t.js";
+import {
+  registerOwnRpcServerInstance,
+  rpcPortDir,
+  rpcPortFilePath,
+  parseRpcPortFile,
+  inspectProcessesAsync
+} from "./server-k3t06fxr.js";
+import {
+  BoundedSessionMap,
+  LkgRecoveryFenceError,
+  lkgServedArrayDigest,
+  takeLkgRecoveryLockSweepPage,
+  hasCleanLkgRecoveryFence,
+  dirtyLkgRecoveryRevision,
+  ownsLkgDirtyFence,
+  invalidateCleanLkgRecoveryFence,
+  prepareLkgCaptureFence,
+  certifyCommittedLkgCapture,
+  markLkgRecoveryDirty,
+  gaDatabasePath,
+  RAW_MESSAGE_TYPES,
+  V2StoreReaderPool,
+  V2StoreReader,
+  cleanSearchText,
+  matchedSearchSnippet,
+  advanceSessionActivity,
+  backfillSessionActivity,
+  getLastIndexedOrdinal2,
+  getMessageIndexReconciliationStartOrdinal2,
+  isMessageIndexReconciledThrough2,
+  clearIndexedMessages2,
+  indexMessagesAfterOrdinal2,
+  sweepOrphanedOpenCodeMessageIndexesCooperatively2
+} from "./server-ppcd1qxh.js";
+import"./server-51779zs2.js";
+import {
+  inRootAsyncContext2,
+  getTagIdentityWriteGeneration2,
+  Database2,
+  getSqliteDatabasePath2,
+  getSqliteMemoryStats2,
+  withSqliteBackgroundWriter2,
+  withSqliteTransformPass2,
+  withoutSqliteTransformPass2,
+  assertTransformWrite2,
+  isTransientSqliteError2,
+  SqliteAcquisitionBusyError2,
+  withAsyncPrivilegedWriter2
+} from "./server-gzy5w8ya.js";
+import {
+  createWorkerShutdown
+} from "./server-cpjk5jd2.js";
+import {
+  isRawCompactionSummaryInfo2,
+  extractInMemoryMessageViews2,
+  buildInMemoryTailRawMessages2,
+  RawOrdinalsNotReady2,
+  runSessionWarmupWorker
+} from "./server-4kjmrjn4.js";
+import {
+  resolveOpenCodeDbPath,
+  assertOpenCodeStoreGeneration,
+  openCodeDbPathExists,
+  recordOpenCodeDbReadFailure,
+  clearOpenCodeDbReadFailure,
+  claimOpenCodeDbDiagnosticOnce
+} from "./server-2ra6pwf3.js";
+import {
+  resolveModelCalibration,
+  calibrateBuckets,
+  resolveDecisionCalibration
+} from "./server-1zx87sdm.js";
+import {
+  protectedToolTagNumbers,
+  protectedToolTokenCount,
+  stripPersistedAssistantText,
+  byteSize,
+  stripTagPrefix,
+  peelLeadingMcTagNotation,
+  prependTag,
+  isThinkingPart,
+  currentReclaimableToolOutputCount,
+  isRecord,
+  contentTagOwnerMessageId,
+  estimateImageTokensFromDataUrl,
+  estimateToolAttachmentImageTokens,
+  providerVisiblePart,
+  normalizeTodoStateJson,
+  buildSyntheticTodoPart,
+  computeSyntheticCallId,
+  isSyntheticTodoPart,
+  countRealUserMessages,
+  tailHygieneStructuralSignature,
+  sameTailHygieneStructuralSignature,
+  formatTailHygienePrefixMismatch,
+  refreshTailHygieneBaseline,
+  effectiveTailHygiene,
+  assertTailHygieneContentUnchangedIfEnabled,
+  CHANNEL1_SENTINEL,
+  CHANNEL1_FLOOR_TOKENS,
+  isDroppedToolOutput,
+  toolOutputTokens,
+  decideChannel1,
+  evaluateChannel2,
+  formatChannel1Evaluation,
+  formatChannel2Evaluation,
+  buildChannel2Reminder,
+  buildChannel1Reminder,
+  estimateEmergencyDropReclaimTokens,
+  planEmergencyDrop,
+  measureEmergencyTag,
+  queuePendingOp,
+  getPendingOps,
+  hasPendingDropOps,
+  getPendingOpsCount,
+  clearPendingOps,
+  removePendingOp,
+  updateTagByteSize2,
+  getRecentTagOwnerMessageIds2,
+  AGE_RECLAIM_MIN_TOKENS2,
+  getOldestActiveUnprotectedToolTags2,
+  getActiveToolTagsForAgeReclaim2,
+  getTriggerTagTokenUpperBound2,
+  getActiveTagTokenTotalsByMessage2,
+  updateTagTokenCount2,
+  tryGetReasoningTokenEstimatesByMessage2,
+  cachedTagOwnerRatios2,
+  tagOwnerWarmupState2,
+  installTagOwnerDelta2,
+  installTagOwnerSummary2,
+  isTagOwnerSummaryReady2,
+  tagTokenCountIsNull2,
+  backfillTagTokenCounts2,
+  insertTag2,
+  updateTagStatus2,
+  markTagDropped2,
+  markWhitespaceAssistantTagInert2,
+  getInertWhitespaceAssistantTags2,
+  getInertWhitespaceAssistantTagsByNumbers2,
+  updateTagDropMode2,
+  updateCavemanDepth2,
+  updateTagMessageId2,
+  markTagsCompactedByMessageIds2,
+  getMaxTagNumberBySession2,
+  getTagNumberByMessageId2,
+  getAssignableTagNumberByMessageId2,
+  deriveTagLoadFloor2,
+  getTagsBySession2,
+  getActiveTagsBySession2,
+  getTailHygieneTags2,
+  getDroppedTagsBySession2,
+  getTagsByNumbers2,
+  getNewestToolTagNumbers2,
+  getDroppedTagsByNumbers2,
+  getMaxDroppedTagNumber2,
+  getTagById2,
+  getToolTagNumberByOwner2,
+  getNullOwnerToolTag2,
+  adoptNullOwnerToolTag2,
+  getCandidateToolOwners2,
+  pickNearestPriorOwner2
+} from "./server-fa7vtp40.js";
+import {
+  textMentionsRecentCommit,
+  hasMeaningfulUserText2,
+  extractTexts2,
+  extractToolCallSummaries,
+  getTokenizerNativeMemoryStats,
+  preloadTokenizer,
+  estimateTokens,
+  estimateFixedPromptTokens,
+  normalizeText
+} from "./server-3mz2qh5a.js";
+import {
+  stableStringify,
+  getTemporalDecisions,
+  observeTemporalDecisions,
+  freezeTemporalDecisions,
+  tagRevisionKey,
+  tagIdentityRevisionKey
+} from "./server-rqebawx1.js";
+import {
+  openCodeDbExists,
+  withReadOnlySessionDb,
+  latestPersistedMessageForRecovery,
+  latestRealUserTurnIdFromOpenCodeDb,
+  getMessageTimesFromOpenCodeDb,
+  findLastAssistantModelFromOpenCodeDb
+} from "./server-3vhxy2k5.js";
 import {
-  detectLatestTurnThinkingMismatch,
-  isPrefixBoundThinkingModel,
-  detectOverflow,
-  ensureSessionMetaRow,
-  clearCachedM0M1,
-  clearCachedM0,
   expandToolPart,
   markHostUnservedRow,
   markCoveredInstructionRow,
@@ -359,6 +546,9 @@ import {
   transitionSessionHygieneUnits,
   readEpochFloorSnapshot,
   getProtectionWindowForSession,
+  ensureSessionMetaRow,
+  clearCachedM0M1,
+  clearCachedM0,
   withReplayEnvelopeSnapshot,
   invalidateReplayEnvelopeSnapshot,
   isRustMarkerAdmissionFenced,
@@ -449,6 +639,9 @@ import {
   getReasoningRemovalState,
   addRemovedReasoningIds,
   markDropLeavesReasoning,
+  detectLatestTurnThinkingMismatch,
+  isPrefixBoundThinkingModel,
+  detectOverflow,
   modelAcceptsEmptyContent,
   isAnthropicFamilyRoute,
   neutralizeDroppedReasoningPart,
@@ -462,12 +655,15 @@ import {
   isInActiveAnthropicTurn,
   activeAnthropicTurnStart,
   hasAnthropicReasoning,
+  markServedShapeRepair,
+  prepareServedShapeRepair,
   stripSystemInjectedMessages,
   stripDroppedPlaceholderMessages,
   replayClearedReasoning,
   replayStrippedInlineThinking,
   clearOldReasoning,
   stripClearedReasoning,
+  captureInlineThinkingRepairs,
   stripInlineThinking,
   findReasoningBearingAssistantIds,
   findLatestAssistantReasoningMutationExemptMessage,
@@ -519,7 +715,24 @@ import {
   readRawSessionMessageById2,
   readSessionChunk2,
   readRawSessionSeedTail2
-} from "./server-9hx7g5jp.js";
+} from "./server-m4bfaevz.js";
+import {
+  getCurrentToolSetHash,
+  recordToolDefinition,
+  getMeasuredToolDefinitionTokens
+} from "./server-d1dzgvwd.js";
+import"./server-dtp8hcjh.js";
+import {
+  SubcClient,
+  connectionFileExists,
+  SYNAPSE_DEFAULT_MODEL,
+  toSynapseLaneDescriptor,
+  formatSynapseLaneDescriptor,
+  SynapseEmbeddingProvider
+} from "./server-ab1g0wn9.js";
+import {
+  deleteChunkEmbedBackoffForSession2
+} from "./server-62g58aaz.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -531,6 +744,7 @@ import {
   getEmbedDrainUiStatus,
   clearEmbedSessionState,
   describeShadowBackfillWriteRefusal2,
+  retainProjectEmbedding2,
   markProjectLoadUntrusted2,
   drainProjectEmbeddingIdentityMaintenance2,
   drainStaleEmbeddingIdentitiesForProject2,
@@ -548,208 +762,7 @@ import {
   embedSessionCompartmentChunks2,
   getEmbeddingCoverageStatus2,
   getAutoEmbeddingSessionCoverage2
-} from "./server-8by8qfec.js";
-import {
-  textMentionsRecentCommit,
-  hasMeaningfulUserText2,
-  extractTexts2,
-  extractToolCallSummaries,
-  getTokenizerNativeMemoryStats,
-  preloadTokenizer,
-  estimateTokens,
-  estimateFixedPromptTokens,
-  normalizeText
-} from "./server-tgnbmwah.js";
-import {
-  SubcClient,
-  connectionFileExists,
-  SYNAPSE_DEFAULT_MODEL,
-  toSynapseLaneDescriptor,
-  formatSynapseLaneDescriptor,
-  SynapseEmbeddingProvider
-} from "./server-6tmj0s7j.js";
-import {
-  inRootAsyncContext2,
-  getTagIdentityWriteGeneration2,
-  Database2,
-  getSqliteDatabasePath2,
-  getSqliteMemoryStats2,
-  withSqliteBackgroundWriter2,
-  withSqliteTransformPass2,
-  withoutSqliteTransformPass2,
-  assertTransformWrite2,
-  isTransientSqliteError2,
-  SqliteAcquisitionBusyError2,
-  withAsyncPrivilegedWriter2
-} from "./server-beht37jy.js";
-import"./server-51779zs2.js";
-import {
-  isRawCompactionSummaryInfo2,
-  extractInMemoryMessageViews2,
-  buildInMemoryTailRawMessages2,
-  RawOrdinalsNotReady2,
-  runSessionWarmupWorker
-} from "./server-xj136kt8.js";
-import"./server-1wy7b9de.js";
-import {
-  deleteChunkEmbedBackoffForSession
-} from "./server-46neh5fa.js";
-import {
-  registerOwnRpcServerInstance,
-  rpcPortDir,
-  rpcPortFilePath,
-  parseRpcPortFile,
-  inspectProcessesAsync
-} from "./server-da07v4xp.js";
-import {
-  BoundedSessionMap,
-  LkgRecoveryFenceError,
-  lkgServedArrayDigest,
-  hasCleanLkgRecoveryFence,
-  dirtyLkgRecoveryRevision,
-  ownsLkgDirtyFence,
-  invalidateCleanLkgRecoveryFence,
-  prepareLkgCaptureFence,
-  certifyCommittedLkgCapture,
-  markLkgRecoveryDirty,
-  cleanSearchText,
-  matchedSearchSnippet,
-  gaDatabasePath,
-  RAW_MESSAGE_TYPES,
-  V2StoreReaderPool,
-  V2StoreReader,
-  advanceSessionActivity,
-  backfillSessionActivity,
-  getLastIndexedOrdinal2,
-  getMessageIndexReconciliationStartOrdinal2,
-  isMessageIndexReconciledThrough2,
-  indexMessagesAfterOrdinal2,
-  sweepOrphanedOpenCodeMessageIndexesCooperatively2
-} from "./server-2ar62dyx.js";
-import {
-  stableStringify,
-  getTemporalDecisions,
-  observeTemporalDecisions,
-  freezeTemporalDecisions,
-  tagRevisionKey,
-  tagIdentityRevisionKey
-} from "./server-pwv4ezb0.js";
-import {
-  resolveModelCalibration,
-  calibrateBuckets,
-  resolveDecisionCalibration
-} from "./server-1zx87sdm.js";
-import {
-  protectedToolTagNumbers,
-  protectedToolTokenCount,
-  stripPersistedAssistantText,
-  byteSize,
-  stripTagPrefix,
-  peelLeadingMcTagNotation,
-  prependTag,
-  isThinkingPart,
-  currentReclaimableToolOutputCount,
-  isRecord,
-  contentTagOwnerMessageId,
-  estimateImageTokensFromDataUrl,
-  estimateToolAttachmentImageTokens,
-  providerVisiblePart,
-  normalizeTodoStateJson,
-  buildSyntheticTodoPart,
-  computeSyntheticCallId,
-  isSyntheticTodoPart,
-  countRealUserMessages,
-  tailHygieneStructuralSignature,
-  sameTailHygieneStructuralSignature,
-  formatTailHygienePrefixMismatch,
-  refreshTailHygieneBaseline,
-  effectiveTailHygiene,
-  assertTailHygieneContentUnchangedIfEnabled,
-  CHANNEL1_SENTINEL,
-  CHANNEL1_FLOOR_TOKENS,
-  isDroppedToolOutput,
-  toolOutputTokens,
-  decideChannel1,
-  evaluateChannel2,
-  formatChannel1Evaluation,
-  formatChannel2Evaluation,
-  buildChannel2Reminder,
-  buildChannel1Reminder,
-  estimateEmergencyDropReclaimTokens,
-  planEmergencyDrop,
-  measureEmergencyTag,
-  queuePendingOp,
-  getPendingOps,
-  hasPendingDropOps,
-  getPendingOpsCount,
-  clearPendingOps,
-  removePendingOp,
-  updateTagByteSize2,
-  getRecentTagOwnerMessageIds2,
-  AGE_RECLAIM_MIN_TOKENS2,
-  getOldestActiveUnprotectedToolTags2,
-  getActiveToolTagsForAgeReclaim2,
-  getTriggerTagTokenUpperBound2,
-  getActiveTagTokenTotalsByMessage2,
-  updateTagTokenCount2,
-  tryGetReasoningTokenEstimatesByMessage2,
-  cachedTagOwnerRatios2,
-  tagOwnerWarmupState2,
-  installTagOwnerDelta2,
-  installTagOwnerSummary2,
-  isTagOwnerSummaryReady2,
-  tagTokenCountIsNull2,
-  backfillTagTokenCounts2,
-  insertTag2,
-  updateTagStatus2,
-  markTagDropped2,
-  markWhitespaceAssistantTagInert2,
-  getInertWhitespaceAssistantTags2,
-  getInertWhitespaceAssistantTagsByNumbers2,
-  updateTagDropMode2,
-  updateCavemanDepth2,
-  updateTagMessageId2,
-  markTagsCompactedByMessageIds2,
-  getMaxTagNumberBySession2,
-  getTagNumberByMessageId2,
-  getAssignableTagNumberByMessageId2,
-  deriveTagLoadFloor2,
-  getTagsBySession2,
-  getActiveTagsBySession2,
-  getTailHygieneTags2,
-  getDroppedTagsBySession2,
-  getTagsByNumbers2,
-  getNewestToolTagNumbers2,
-  getDroppedTagsByNumbers2,
-  getMaxDroppedTagNumber2,
-  getTagById2,
-  getToolTagNumberByOwner2,
-  getNullOwnerToolTag2,
-  adoptNullOwnerToolTag2,
-  getCandidateToolOwners2,
-  pickNearestPriorOwner2
-} from "./server-27gq4mfz.js";
-import {
-  resolveOpenCodeDbPath,
-  assertOpenCodeStoreGeneration,
-  openCodeDbPathExists,
-  recordOpenCodeDbReadFailure,
-  clearOpenCodeDbReadFailure,
-  claimOpenCodeDbDiagnosticOnce
-} from "./server-2ra6pwf3.js";
-import {
-  openCodeDbExists,
-  withReadOnlySessionDb,
-  latestPersistedMessageForRecovery,
-  latestRealUserTurnIdFromOpenCodeDb,
-  getMessageTimesFromOpenCodeDb,
-  findLastAssistantModelFromOpenCodeDb
-} from "./server-n1prf1g6.js";
-import {
-  getCurrentToolSetHash,
-  recordToolDefinition,
-  getMeasuredToolDefinitionTokens
-} from "./server-g3qma5c0.js";
+} from "./server-ad18djzs.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY
@@ -762,7 +775,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace,
   computeWorkspaceEpochFingerprint
-} from "./server-xq7dfjke.js";
+} from "./server-wwaw5npa.js";
 import {
   configureContextDatabasePragmas2
 } from "./server-fb3zxn06.js";
@@ -808,15 +821,15 @@ import {
   readGitFileChangeTimesSince,
   verificationFileExists,
   normalizeVerificationFiles
-} from "./server-hm38q7r0.js";
+} from "./server-d48x3m4x.js";
 import {
   deriveTriggerBudget2,
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianProducerLimits2,
   resolveHistorianContextLimit2
-} from "./server-34kwfsr4.js";
-import"./server-d04vrx0j.js";
+} from "./server-53eh1r8r.js";
+import"./server-806rzhs6.js";
 import {
   isEmbeddingHostBusy2
 } from "./server-qt1qqasc.js";
@@ -829,18 +842,20 @@ import {
   releaseGitSweepLease,
   recordSessionProjectIdentity,
   hasRecordedSessionProjectIdentity
-} from "./server-hy3d3vsx.js";
+} from "./server-bsgd4dk1.js";
 import {
   saveEmbeddingIfHashMatches,
   invalidateProject2,
   invalidateMemory2
 } from "./server-4dhv7mqz.js";
 import {
+  getCachedLocalEmbeddingPooling,
+  preflightLocalEmbeddingPooling,
   getLocalEmbeddingNativeMemoryStats
-} from "./server-h1v0pyxb.js";
+} from "./server-vr4szghm.js";
 import {
   cosineSimilarity
-} from "./server-zzkj2fch.js";
+} from "./server-qteg2kt9.js";
 import {
   computeCueContentHash,
   hasMuralCueColumns,
@@ -865,7 +880,7 @@ import {
   mergeMemoryStats2,
   archiveMemory2,
   getMemoryCountsByStatus2
-} from "./server-n37sebck.js";
+} from "./server-jjvbk92s.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -873,11 +888,11 @@ import {
   drainNotifications2,
   isTuiConnected2
 } from "./server-x8a7jmkh.js";
-import"./server-h0410h0v.js";
+import"./server-1bw1wcbp.js";
 import {
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./server-a9xqj88f.js";
+} from "./server-6v3cdzsx.js";
 import {
   renderSingleStoreMigrationRequiredRefusal,
   SingleStoreMigrationRequiredError,
@@ -897,14 +912,14 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./server-gsxjv2q2.js";
+} from "./server-33nqbqkw.js";
 import {
   resolvePromptContext2
 } from "./server-fmsr7v69.js";
 import"./server-kaqs6h31.js";
 import {
   renderSearchArchiveOffThread2
-} from "./server-45q69hkq.js";
+} from "./server-132h8twc.js";
 import {
   compareSemverCore
 } from "./server-84w6rvvf.js";
@@ -944,7 +959,7 @@ import {
 } from "./server-8ajstryz.js";
 import {
   logSlowWriteTransaction
-} from "./server-6pmqg9m4.js";
+} from "./server-gyy4k6mf.js";
 import {
   shouldEnforcePrivateStoragePermissions,
   ensureStorageDirectorySync,
@@ -1720,6 +1735,270 @@ function summarizeManualDream(summary) {
 `);
 }
 
+// src/features/magic-context/message-index-async.ts
+var indexCancellations = new Map;
+var sessionEpochs = new Map;
+var workerMeasurements = new WeakMap;
+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;
+  reconciledSnapshots = new Map;
+  stalledSessions = 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 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") {
+    inRootAsyncContext2(() => immediate(fn));
+    return;
+  }
+  inRootAsyncContext2(() => 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)) {
+    sessionLog2(sessionId, `message FTS async ${action} skipped (database busy; will retry on next reconciliation)`);
+    return;
+  }
+  sessionLog2(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
+  log2(`[message-index-async] ${action} failed for ${sessionId}:`, error);
+}
+function serializedMessageBytes(messages) {
+  try {
+    return Buffer.byteLength(JSON.stringify(messages));
+  } catch {
+    return 0;
+  }
+}
+function logReconciliationStall(sessionId, reason) {
+  if (heapHolder.stalledSessions.has(sessionId))
+    return;
+  heapHolder.stalledSessions.add(sessionId);
+  sessionLog2(sessionId, `message FTS reconciliation stalled: ${reason}; will retry`);
+}
+async function reconcileSessionIndex(db, sessionId, readMessages) {
+  if (!await sourceReady(readMessages, sessionId)) {
+    logReconciliationStall(sessionId, "raw message reader is not ready");
+    return false;
+  }
+  await runWithSessionLock(sessionId, async () => {
+    if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId))
+      return;
+    let fallbackSnapshot = null;
+    try {
+      const fullReader = typeof readMessages === "function" ? readMessages : null;
+      const revision = readMessages.getRevision?.(sessionId);
+      const previous = heapHolder.reconciledSnapshots.get(sessionId);
+      const finalWatermark = previous && revision === previous.revision ? previous.count : revision !== undefined && readMessages.getCountAfterRevision ? previous && revision > previous.revision ? previous.count + readMessages.getCountAfterRevision(sessionId, previous.revision, revision) : readMessages.getCountAfterRevision(sessionId, -1, revision) : readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
+      let cursor = getMessageIndexReconciliationStartOrdinal2(db, sessionId);
+      let after = cursor === previous?.count ? previous.after : undefined;
+      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);
+        withSqliteBackgroundWriter2(() => indexMessagesAfterOrdinal2(db, sessionId, messages, cursor, pageEnd));
+        const nextCursor = getMessageIndexReconciliationStartOrdinal2(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 (isMessageIndexReconciledThrough2(db, sessionId, finalWatermark)) {
+        heapHolder.reconciledSessions.add(sessionId);
+        if (revision !== undefined) {
+          if (!after && finalWatermark > 0 && readMessages.readPage) {
+            const last = readMessages.readPage(sessionId, finalWatermark - 1, 1, finalWatermark).at(-1);
+            if (last?.ordinal === finalWatermark && typeof last.createdAt === "number")
+              after = { timeCreated: last.createdAt, id: last.id };
+          }
+          heapHolder.reconciledSnapshots.set(sessionId, {
+            revision,
+            count: finalWatermark,
+            after
+          });
+        }
+      } else {
+        logReconciliationStall(sessionId, `gap after ordinal ${cursor} (store count ${finalWatermark})`);
+      }
+    } finally {
+      heapHolder.activeReconcilerBuffers.delete(sessionId);
+    }
+  });
+  return true;
+}
+function scheduleReconciliation(db, sessionId, readMessages) {
+  if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
+    return;
+  }
+  heapHolder.reconciliationScheduledSessions.add(sessionId);
+  scheduleAfterBootQuiet(() => {
+    defer(() => {
+      let appendedDuringReconciliation = false;
+      const previousSnapshot = heapHolder.reconciledSnapshots.get(sessionId);
+      reconcileSessionIndex(db, sessionId, readMessages).then((ran) => {
+        if (ran) {
+          const snapshot = heapHolder.reconciledSnapshots.get(sessionId);
+          appendedDuringReconciliation = snapshot !== undefined && snapshot !== previousSnapshot && readMessages.getRevision !== undefined && readMessages.getRevision(sessionId) !== snapshot.revision;
+          return;
+        }
+        inRootAsyncContext2(() => setTimeout(() => {
+          heapHolder.reconciliationScheduledSessions.delete(sessionId);
+          scheduleReconciliation(db, sessionId, readMessages);
+        }, PREPARE_RETRY_MS)).unref?.();
+      }).catch((error) => {
+        logReconciliationStall(sessionId, error instanceof Error ? error.message : String(error));
+        if (isDatabaseLockedError(error))
+          inRootAsyncContext2(() => setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000)).unref();
+      }).finally(() => {
+        heapHolder.reconciliationScheduledSessions.delete(sessionId);
+        if (appendedDuringReconciliation)
+          scheduleReconciliation(db, sessionId, readMessages);
+      });
+    });
+  });
+}
+async function sweepOrphanedOpenCodeMessageIndexesOffThread(db, openSource, options = {}) {
+  if (getHarness2() === "opencode" || getHarness2() === "opencode2")
+    options = {
+      ...options,
+      fenceLockNames: options.fenceLockNames ?? takeLkgRecoveryLockSweepPage()
+    };
+  if (getHarness2() === "opencode2")
+    openSource = () => new Database2(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), {
+      readonly: true,
+      fileMustExist: true
+    });
+  const path = getSqliteDatabasePath2(db);
+  if (!path || getHarness2() !== "opencode" && getHarness2() !== "opencode2")
+    return sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, openSource, options);
+  let source = null;
+  let sourcePath = null;
+  try {
+    source = openSource();
+    if (source)
+      sourcePath = getSqliteDatabasePath2(source);
+  } catch {} finally {
+    if (sourcePath)
+      source?.close();
+  }
+  if (!sourcePath)
+    return sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, () => source, options);
+  const reply = await runSessionWarmupWorker({
+    path,
+    sessionId: "",
+    harness: getHarness2(),
+    orphanSweep: { sourcePath, options }
+  }, {});
+  if (!("orphanSweep" in reply))
+    throw new Error("message history orphan sweep worker failed");
+  return reply.orphanSweep;
+}
+function scheduleClearAndReindex(db, sessionId, readMessages) {
+  heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciledSnapshots.delete(sessionId);
+  heapHolder.reconciliationScheduledSessions.delete(sessionId);
+  clearCompletedIncrementalKeys(sessionId);
+  const existing = heapHolder.clearAndReindexScheduledSessions.get(sessionId);
+  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);
+        heapHolder.reconciledSnapshots.delete(sessionId);
+        clearCompletedIncrementalKeys(sessionId);
+        clearIndexedMessages2(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 = [
   {
@@ -3182,7 +3461,7 @@ function dropCompartmentsAfter(db, sessionId, anchor, holderId, activeBranch = f
       if (marker && clearPendingPiCompactionMarkerStateIf(db, sessionId, marker, null))
         clearedMarker = marker;
     }
-    deleteChunkEmbedBackoffForSession(db, sessionId);
+    deleteChunkEmbedBackoffForSession2(db, sessionId);
     queueM0Mutation(db, { sessionId, mutationType: "recomp_boundary_change" });
     clearCachedM0M1(db, sessionId);
     db.exec("COMMIT");
@@ -3298,192 +3577,6 @@ function capDreamerReadOutput(input, output) {
   return true;
 }
 
-// src/features/magic-context/message-index-async.ts
-var indexCancellations = new Map;
-var sessionEpochs = new Map;
-var workerMeasurements = new WeakMap;
-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;
-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") {
-    inRootAsyncContext2(() => immediate(fn));
-    return;
-  }
-  inRootAsyncContext2(() => 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)) {
-    sessionLog2(sessionId, `message FTS async ${action} skipped (database busy; will retry on next reconciliation)`);
-    return;
-  }
-  sessionLog2(sessionId, `message FTS async ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
-  log2(`[message-index-async] ${action} failed for ${sessionId}:`, error);
-}
-function serializedMessageBytes(messages) {
-  try {
-    return Buffer.byteLength(JSON.stringify(messages));
-  } catch {
-    return 0;
-  }
-}
-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 = getMessageIndexReconciliationStartOrdinal2(db, sessionId);
-      let after;
-      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);
-        withSqliteBackgroundWriter2(() => indexMessagesAfterOrdinal2(db, sessionId, messages, cursor, pageEnd));
-        const nextCursor = getMessageIndexReconciliationStartOrdinal2(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 (isMessageIndexReconciledThrough2(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;
-        inRootAsyncContext2(() => setTimeout(() => {
-          heapHolder.reconciliationScheduledSessions.delete(sessionId);
-          scheduleReconciliation(db, sessionId, readMessages);
-        }, PREPARE_RETRY_MS)).unref?.();
-      }).catch((error) => {
-        logIndexingError(sessionId, "reconciliation", error);
-        if (isDatabaseLockedError(error))
-          inRootAsyncContext2(() => setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000)).unref();
-      }).finally(() => {
-        heapHolder.reconciliationScheduledSessions.delete(sessionId);
-      });
-    });
-  });
-}
-async function sweepOrphanedOpenCodeMessageIndexesOffThread(db, openSource, options = {}) {
-  if (getHarness2() === "opencode2")
-    openSource = () => new Database2(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), {
-      readonly: true,
-      fileMustExist: true
-    });
-  const path = getSqliteDatabasePath2(db);
-  if (!path || getHarness2() !== "opencode" && getHarness2() !== "opencode2")
-    return sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, openSource, options);
-  let source = null;
-  let sourcePath = null;
-  try {
-    source = openSource();
-    if (source)
-      sourcePath = getSqliteDatabasePath2(source);
-  } catch {} finally {
-    if (sourcePath)
-      source?.close();
-  }
-  if (!sourcePath)
-    return sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, () => source, options);
-  const reply = await runSessionWarmupWorker({
-    path,
-    sessionId: "",
-    harness: getHarness2(),
-    orphanSweep: { sourcePath, options }
-  }, {});
-  if (!("orphanSweep" in reply))
-    throw new Error("message history orphan sweep worker failed");
-  return reply.orphanSweep;
-}
-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;
@@ -4145,7 +4238,8 @@ ${trimmedBody}…
   return wrapped;
 }
 function selectAutoSearchResults(results, threshold) {
-  return results.filter((result) => (result.relevanceScore ?? result.score) >= threshold);
+  const relevance = (result) => result.relevanceScore ?? result.score;
+  return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
 // src/hooks/magic-context/auto-search-worker-client.ts
@@ -4238,22 +4332,42 @@ function retryUnpublishedAutoSearchNoHint(db, sessionId, messageId, startedAt) {
   }
   return true;
 }
+
+class AutoSearchBusyError extends Error {
+  constructor() {
+    super("an earlier auto-search of this session is still running");
+    this.name = "AutoSearchBusyError";
+  }
+}
 async function searchAutoHint(db, sessionId, projectPath, query, options, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./auto-search-worker.ts" : "./auto-search-worker.js", import.meta.url)) {
-  return executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, "search");
+  const {
+    rerankConfig: _rerankConfig,
+    rerankClient: _rerankClient,
+    rerankConnectionFile: _rerankConnectionFile,
+    onRerankSkipped: _onRerankSkipped,
+    captureRerankLanes: _captureRerankLanes,
+    ...hintOptions
+  } = options;
+  return executeAutoSearchWorker(db, sessionId, projectPath, query, { ...hintOptions, explicitSearch: false, rerank: false }, entry, "search");
 }
 var pendingBackfills = new WeakMap;
 var searchWorkers = new WeakMap;
 var liveSearchWorkers = new Set;
 var MAX_IDLE_SEARCH_WORKERS = 4;
 var SEARCH_WORKER_IDLE_MS = 5 * 60000;
+var DETACHED_SEARCH_LIMIT_MS = 30000;
+var AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var workersCreated = 0;
 var workersReused = 0;
+var searchesSkippedBusy = 0;
 async function acquireSearchWorker(db, key, entry, input, signal) {
   const pool = searchWorkers.get(db) ?? new Map;
   searchWorkers.set(db, pool);
   while (!signal.aborted) {
     let slot = pool.get(key);
     if (slot?.busy) {
+      if (input.job === "search" && (slot.detached || slot.busySessionId === input.sessionId))
+        return "busy";
       const current = slot;
       await new Promise((resolve) => {
         const done = () => {
@@ -4262,6 +4376,8 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
         };
         signal.addEventListener("abort", done, { once: true });
         current.busy?.then(done);
+        if (!current.detached)
+          current.detachedSignal?.then(done);
         if (signal.aborted)
           done();
       });
@@ -4270,14 +4386,16 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     const fresh = !slot;
     if (!slot) {
       const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
         dispose() {
+          this.disposed = true;
           clearTimeout(this.idleTimer);
           if (pool.get(key) === this)
             pool.delete(key);
           liveSearchWorkers.delete(this);
-          worker.terminate();
+          shutdown.close();
           worker.unref();
         }
       };
@@ -4291,9 +4409,14 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
       workersReused++;
     clearTimeout(slot.idleTimer);
     const current = slot;
+    current.busySessionId = input.sessionId;
+    current.detached = false;
     current.busy = new Promise((resolve) => {
       current.release = resolve;
     });
+    current.detachedSignal = new Promise((resolve) => {
+      current.markDetached = resolve;
+    });
     current.worker.ref();
     return { slot: current, fresh };
   }
@@ -4302,6 +4425,9 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
 function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   if (isEmbeddingHostBusy2())
     return Promise.resolve();
+  const snapshot = getProjectEmbeddingSnapshot2(projectPath);
+  if (!snapshot?.enabled || !snapshot.features.memoryEnabled)
+    return Promise.resolve();
   const key = `${sessionId}\x00${projectPath}`;
   const pending = pendingBackfills.get(db) ?? new Map;
   pendingBackfills.set(db, pending);
@@ -4349,6 +4475,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     signal: deadlineSignal,
     readMessages: _readMessages,
     searchMessageHistory: _searchMessageHistory,
+    stepTimings: _stepTimings,
     ...serializable
   } = options;
   const lifecycle = registerAutoSearchWork(sessionId);
@@ -4384,30 +4511,55 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     lifecycle.done();
     return [];
   }
+  if (lease === "busy") {
+    lifecycle.done();
+    searchesSkippedBusy++;
+    throw new AutoSearchBusyError;
+  }
   const { slot, fresh } = lease;
   const worker = slot.worker;
+  const detachable = job === "search" && entry.href === defaultAutoSearchWorkerEntry().href;
+  const startedAt = performance.now();
+  let detachedAt;
+  let ownerVectorMs;
+  let abandonTimer;
   return new Promise((resolve, reject) => {
     let settled = false;
-    const finish = (results, error) => {
+    let released = false;
+    const settle = (results, error) => {
       if (settled)
         return;
       settled = true;
+      if (error)
+        reject(error);
+      else
+        resolve(results);
+    };
+    const release = (dispose) => {
+      if (released)
+        return;
+      released = true;
+      clearTimeout(abandonTimer);
       signal?.removeEventListener("abort", abort);
       lifecycle.signal.removeEventListener("abort", abort);
       lifecycle.done();
       worker.off("message", onMessage);
       worker.off("error", onError);
       worker.off("exit", onExit);
-      if (error || signal.aborted || entry.href !== defaultAutoSearchWorkerEntry().href)
+      if (dispose || !detachable)
         slot.dispose();
-      else {
+      else if (!slot.disposed) {
         slot.idleTimer = setTimeout(() => slot.dispose(), SEARCH_WORKER_IDLE_MS);
         slot.idleTimer.unref?.();
       }
-      const release = slot.release;
+      const free = slot.release;
       slot.busy = undefined;
       slot.release = undefined;
-      release?.();
+      slot.busySessionId = undefined;
+      slot.detached = false;
+      slot.detachedSignal = undefined;
+      slot.markDetached = undefined;
+      free?.();
       const reusable = liveSearchWorkers.delete(slot);
       if (reusable)
         liveSearchWorkers.add(slot);
@@ -4415,51 +4567,82 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       for (const prior of idle.slice(0, Math.max(0, idle.length - MAX_IDLE_SEARCH_WORKERS)))
         prior.dispose();
       worker.unref();
-      if (error)
-        reject(error);
-      else
-        resolve(results);
     };
-    const abort = () => finish([]);
+    const finish = (results, error) => {
+      settle(results, error);
+      release(Boolean(error) || signal.aborted);
+    };
+    const abort = () => {
+      if (lifecycle.signal.aborted || !detachable) {
+        finish([]);
+        return;
+      }
+      if (settled)
+        return;
+      detachedAt = performance.now();
+      slot.detached = true;
+      slot.markDetached?.();
+      settle([]);
+      abandonTimer = setTimeout(() => {
+        log2(`[auto-search] session ${sessionId}: search still running ${DETACHED_SEARCH_LIMIT_MS} ms after its deadline; disposing its worker (owner vector wait ${formatMs(ownerVectorMs)})`);
+        release(true);
+      }, DETACHED_SEARCH_LIMIT_MS);
+      abandonTimer.unref?.();
+    };
     signal?.addEventListener("abort", abort, { once: true });
     lifecycle.signal.addEventListener("abort", abort, { once: true });
     const onError = (error) => finish([], error);
     const onExit = (code) => finish([], new Error(`auto-search worker exited (${code})`));
     const onMessage = async (reply) => {
-      if (settled)
+      if (released)
         return;
-      if (reply.kind === "result") {
+      if (reply.kind === "result" || reply.kind === "error") {
+        if (detachedAt !== undefined) {
+          logLateSearch(sessionId, performance.now() - detachedAt, detachedAt - startedAt, ownerVectorMs, reply.kind === "result" ? reply.timings : undefined, reply.kind === "error");
+          release(reply.kind === "error");
+          return;
+        }
+        if (reply.kind === "error") {
+          finish([], new Error(reply.error));
+          return;
+        }
         if (snapshot && getProjectEmbeddingSnapshot2(projectPath)?.generation !== snapshot.generation)
           finish([]);
         else
           finish(reply.results);
         return;
       }
-      if (reply.kind === "error") {
-        finish([], new Error(reply.error));
-        return;
-      }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
       const response = { id: reply.id };
-      try {
+      if (!signal.aborted) {
+        const requestedAt = performance.now();
+        try {
+          if (reply.kind === "query")
+            response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
+          else {
+            const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
+            const current = getProjectEmbeddingSnapshot2(projectPath);
+            response.passage = passage && current ? {
+              ...passage,
+              providerIdentity: current.providerIdentity,
+              runtimeFingerprint: current.runtimeFingerprint,
+              dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
+            } : null;
+          }
+        } catch (error) {
+          response.error = error instanceof Error ? error.message : String(error);
+        }
         if (reply.kind === "query")
-          response.result = await (job === "backfill" ? embedTextForProject2(projectPath, reply.text, signal, "query") : boundedHintEmbedding(embedQuery, reply.text, signal)) ?? null;
-        else {
-          const passage = await embedBatchForProject2(projectPath, reply.texts, signal, reply.purpose);
-          const current = getProjectEmbeddingSnapshot2(projectPath);
-          response.passage = passage && current ? {
-            ...passage,
-            providerIdentity: current.providerIdentity,
-            runtimeFingerprint: current.runtimeFingerprint,
-            dimensions: passage.vectors.find((vector) => vector !== null)?.length ?? null
-          } : null;
+          ownerVectorMs = performance.now() - requestedAt;
+        if (signal.aborted) {
+          response.result = undefined;
+          response.passage = undefined;
+          response.error = undefined;
         }
-      } catch (error) {
-        response.error = error instanceof Error ? error.message : String(error);
       }
       response.embeddingHostBusy = isEmbeddingHostBusy2();
-      if (!settled && !signal?.aborted) {
+      if (!released) {
         try {
           worker.postMessage(response);
         } catch (error) {
@@ -4481,6 +4664,15 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     }
   });
 }
+function formatMs(value) {
+  return value === undefined ? "n/a" : `${Math.round(value)} ms`;
+}
+function logLateSearch(sessionId, lateMs, waitedMs, ownerVectorMs, timings, failed) {
+  const steps = timings?.steps;
+  const warm = timings?.lastPoolWarm;
+  const pool = warm ? `last pool refresh ${warm.outcome} in ${formatMs(warm.totalMs)} (probe ${formatMs(warm.probeMs)}, read ${formatMs(warm.readMs)}, decode ${formatMs(warm.decodeMs)}, ${warm.probedRows} rows probed, ${warm.decodedRows} decoded)` : "no pool refresh yet";
+  log2(`[auto-search] session ${sessionId}: deadline passed after ${formatMs(waitedMs)}; the search ${failed ? "failed" : "finished"} ${formatMs(lateMs)} later. Steps: message FTS ${formatMs(steps?.messageMs)}, vector wait ${formatMs(steps?.vectorWaitMs)} (owner embedding ${formatMs(ownerVectorMs)}), chunk lane ${formatMs(steps?.chunkMs)} (pool ${steps?.chunkPool ?? "n/a"}), other lanes ${formatMs(steps?.otherLanesMs)}, job ${formatMs(timings?.jobMs)}; ${pool}`);
+}
 async function boundedHintEmbedding(embed, text, signal) {
   const controller = new AbortController;
   const combined = AbortSignal.any([signal, controller.signal]);
@@ -4504,6 +4696,7 @@ function defaultAutoSearchWorkerEntry() {
 }
 var MESSAGE_WORKER_ACCEPT_TIMEOUT_MS = 400;
 var MESSAGE_WORKER_RESULT_TIMEOUT_MS = 30000;
+var MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS = 2000;
 var messageSearchWorkerFallbacks = new Map;
 function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWorkerEntry(), deadlines = {}) {
   const fallback = (reason, detail) => {
@@ -4531,6 +4724,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
   return new Promise((resolve) => {
     let settled = false;
     let worker;
+    let shutdown;
     let deadline;
     const finish = (outcome, reason, detail) => {
       if (settled)
@@ -4539,7 +4733,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
       clearTimeout(deadline);
       if (reason)
         fallback(reason, detail);
-      worker?.terminate();
+      shutdown?.close();
       worker?.unref();
       resolve(outcome);
     };
@@ -4550,6 +4744,7 @@ function searchMessageHistoryOffThread(db, request, entry = defaultAutoSearchWor
     };
     try {
       worker = inRootAsyncContext2(() => new Worker(entry, { workerData: input }));
+      shutdown = createWorkerShutdown(worker, "message-search", MESSAGE_SEARCH_WORKER_CLOSE_DEADLINE_MS);
     } catch (error) {
       finish(null, "start-failed", error);
       return;
@@ -4818,7 +5013,8 @@ async function runAutoSearchHint(args) {
           },
           isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
           visibleMemoryIds: options.visibleMemoryIds ?? null,
-          sources: ["memory", "message", "git_commit"]
+          sources: ["memory", "message", "git_commit"],
+          chunkPoolWarmOnly: true
         };
         return searchAutoHint(db, sessionId, options.projectPath, rawPrompt, {
           ...searchOptions,
@@ -4829,6 +5025,11 @@ async function runAutoSearchHint(args) {
     } catch (error) {
       if (lifecycleSignal.aborted)
         return AUTO_SEARCH_OK;
+      if (error instanceof AutoSearchBusyError) {
+        sessionLog2(sessionId, "auto-search: an earlier search of this session is still running, skipping hint for this turn");
+        persistAutoSearchSkip(db, sessionId, userMsgId);
+        return { ok: false, kind: "timeout" };
+      }
       log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
       const outcome = await writeNoHintAndReconcile("error");
       return outcome.ok ? { ok: false, kind: "search-failure" } : outcome;
@@ -4878,7 +5079,7 @@ ${hintText}`;
       if (outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
-      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
+      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top relevance ${(results[0].relevanceScore ?? results[0].score).toFixed(3)})`);
       return AUTO_SEARCH_OK;
     } finally {
       if (!lifecycleSignal.aborted && results !== null)
@@ -4935,6 +5136,30 @@ function getSessionErrorInfo(properties) {
   };
 }
 
+// src/hooks/magic-context/diagnostic-log-state.ts
+var states = new BoundedSessionMap(1000);
+var scope = (sessionId) => `${getMagicContextStorageDir()}\x00${getHarness2()}\x00${sessionId}`;
+function diagnosticStateChanged(sessionId, category, state) {
+  const key = scope(sessionId);
+  const previous = states.get(key) ?? new Map;
+  if (previous.get(category) === state)
+    return false;
+  previous.set(category, state);
+  states.set(key, previous);
+  return true;
+}
+function clearDiagnosticLogState(sessionId) {
+  states.delete(scope(sessionId));
+}
+
+// src/hooks/magic-context/nudge-evaluation-log.ts
+function logNudgeEvaluation(sessionId, phase, line) {
+  const category = `${phase}:${line.split(":", 1)[0]}`;
+  const state = line.split(" ").filter((field) => /^(ctx_reduce|band|dampening|verdict|reason|lease)=/.test(field)).join(" ");
+  if (diagnosticStateChanged(sessionId, category, state))
+    sessionLog2(sessionId, line);
+}
+
 // src/features/magic-context/dreamer/storage-task-schedule.ts
 function toRow(r) {
   return {
@@ -5811,7 +6036,7 @@ function canConsumeDeferredOnThisPass(args) {
   return args.schedulerDecision === "execute" || args.contextPercentage >= (args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage);
 }
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true;
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.subagentExecute === true || signals.executeReclaim === true || signals.servedShapeRepair === true;
 }
 function prefixMutationPermitted(gate) {
   return !gate.signedThinkingHold || gate.firstRender || gate.idleExpiry || gate.emergency;
@@ -5824,13 +6049,234 @@ var RECLAIM_RIDE_NAMES = [
   "force",
   "explicitFlush",
   "publishedHistory",
-  "subagentExecute"
+  "subagentExecute",
+  "executeReclaim",
+  "servedShapeRepair"
 ];
 function reclaimRideLabel(signals) {
   const active = RECLAIM_RIDE_NAMES.filter((name) => signals[name]);
   return `ride=${active.length > 0 ? active.join("+") : "none"}`;
 }
 
+// src/hooks/magic-context/pending-drop-eligibility.ts
+function pendingDropVeto(tagNumber, target, protectedTagIds) {
+  if (protectedTagIds.has(tagNumber))
+    return "protected";
+  if (target?.thinkingDropProtected)
+    return "active_thinking";
+  return null;
+}
+function capturePendingDropEligibility(targets, protectedTagIds) {
+  const eligible = new Set;
+  for (const [number, target] of targets) {
+    if (pendingDropVeto(number, target, protectedTagIds))
+      continue;
+    if (target.drop) {
+      if (target.canDrop?.() === true)
+        eligible.add(number);
+    } else {
+      const content = target.getContent?.();
+      const replacement = `[dropped §${number}§]`;
+      if (typeof content === "string" && content.length > replacement.length && target.canSetContent?.(replacement) !== false)
+        eligible.add(number);
+    }
+  }
+  return eligible;
+}
+function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
+  const digests = input.map((message) => message.contentDigest?.() ?? null);
+  if (digests.some((digest) => digest === null))
+    return null;
+  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
+  if (!revision?.value)
+    return null;
+  return JSON.stringify([
+    input.map((message, index) => [
+      message.id,
+      message.role,
+      message.synthetic,
+      digests[index]
+    ]),
+    revision.value,
+    readEpochFloorSnapshot(db, sessionId),
+    sessionDecisionCalibration(db, sessionId).toolsRatio,
+    loadProtectedTailMeta(db, sessionId),
+    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
+    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
+    protectionInputs
+  ]);
+}
+function createPendingDropEligibilityCache() {
+  const sessions = new Map;
+  return {
+    read(sessionId, key) {
+      const previous = sessions.get(sessionId);
+      if (key === null || previous?.key !== key) {
+        sessions.delete(sessionId);
+        return;
+      }
+      return previous.eligible;
+    },
+    record(sessionId, key, eligible) {
+      sessions.delete(sessionId);
+      if (key === null)
+        return;
+      const oldest = sessions.keys().next().value;
+      if (sessions.size >= 64 && oldest !== undefined)
+        sessions.delete(oldest);
+      sessions.set(sessionId, { key, eligible: new Set(eligible) });
+    }
+  };
+}
+
+// src/hooks/magic-context/postprocess-read-cache.ts
+var connections = new WeakMap;
+function snapshot(db, sessionId) {
+  const transaction = db;
+  try {
+    if (transaction.inTransaction || transaction.isTransaction) {
+      connections.delete(db);
+      return { version: -1, changes: -1 };
+    }
+  } catch {
+    connections.delete(db);
+    return { version: -1, changes: -1 };
+  }
+  let connection = connections.get(db);
+  if (!connection) {
+    connection = {
+      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
+      sessions: new BoundedSessionMap(100)
+    };
+    connections.set(db, connection);
+  }
+  const stamp = connection.stamp.get();
+  const previous = connection.sessions.get(sessionId);
+  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
+    return previous;
+  }
+  const value = { ...stamp };
+  connection.sessions.set(sessionId, value);
+  return value;
+}
+function postprocessTailTags(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  return state.tags ??= getTailHygieneTags2(db, sessionId);
+}
+function postprocessOldestTags(db, sessionId, protectedNumbers) {
+  const state = snapshot(db, sessionId);
+  const hints = state.hints;
+  if (hints && hints.protectedNumbers.size === protectedNumbers.size && [...protectedNumbers].every((number) => hints.protectedNumbers.has(number))) {
+    return hints.value;
+  }
+  const value = getOldestActiveUnprotectedToolTags2(db, sessionId, protectedNumbers);
+  state.hints = { protectedNumbers: new Set(protectedNumbers), value };
+  return value;
+}
+function postprocessReplaySnapshot(db, sessionId) {
+  const state = snapshot(db, sessionId);
+  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
+  return {
+    ...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),
+    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
+    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
+    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
+    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
+    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
+    compactionMarker: structuredClone(replay.compactionMarker)
+  };
+}
+
+// src/hooks/magic-context/execute-reclaim.ts
+var NAMESPACE = "executeReclaim";
+var failedWrites = new WeakMap;
+function readExecuteReclaimState(db, sessionId) {
+  return parseState(postprocessReplaySnapshot(db, sessionId).executeReclaim);
+}
+function parseState(lane) {
+  const value = lane;
+  return {
+    heldPasses: typeof value?.heldPasses === "number" ? Math.max(0, value.heldPasses) : 0,
+    floorOrdinal: typeof value?.floorOrdinal === "number" ? value.floorOrdinal : null,
+    floorPromptId: typeof value?.floorPromptId === "string" ? value.floorPromptId : null
+  };
+}
+function writeExecuteReclaimState(db, sessionId, patch) {
+  if (failedWrites.get(db)?.has(sessionId))
+    return false;
+  try {
+    const current = readExecuteReclaimState(db, sessionId);
+    if (JSON.stringify(current) === JSON.stringify({ ...current, ...patch }))
+      return true;
+    if (!updateReplayDocument(db, sessionId, (doc) => {
+      const previous = parseState(doc[NAMESPACE]);
+      const state = { ...previous, ...patch };
+      if (JSON.stringify(previous) === JSON.stringify(state))
+        return false;
+      doc.version = 2;
+      doc[NAMESPACE] = state;
+      return true;
+    }))
+      throw new Error("Could not persist execute reclaim state");
+    return true;
+  } catch (error) {
+    let failed = failedWrites.get(db);
+    if (!failed)
+      failedWrites.set(db, failed = new Set);
+    failed.add(sessionId);
+    sessionLog2(sessionId, `execute reclaim state persistence failed; retaining existing policy: ${String(error)}`);
+    return false;
+  }
+}
+function clearExecuteReclaimState(db, sessionId) {
+  writeExecuteReclaimState(db, sessionId, {
+    heldPasses: 0,
+    floorOrdinal: null,
+    floorPromptId: null
+  });
+}
+function maintainExecuteFloorMark(db, sessionId, promptId, belowExecute) {
+  failedWrites.get(db)?.delete(sessionId);
+  const state = readExecuteReclaimState(db, sessionId);
+  if (state.floorOrdinal !== null && (belowExecute || promptId !== null && promptId !== state.floorPromptId)) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
+}
+function estimateExecuteReclaimTokens(args) {
+  const eligible = capturePendingDropEligibility(args.targets, args.protectedTagIds);
+  const queued = new Set(args.pendingOps.filter((op) => op.operation === "drop").map((op) => op.tagId));
+  const candidates = args.tags.filter((tag) => tag.status === "active" && queued.has(tag.tagNumber) && eligible.has(tag.tagNumber));
+  const preparationTargets = new Map;
+  for (const tag of candidates) {
+    const target = args.targets.get(tag.tagNumber);
+    if (target?.prepareDrop)
+      preparationTargets.set(tag.tagNumber, target);
+  }
+  const prepared = preparationTargets.size === 0 ? new Set : args.probePreparation?.(preparationTargets) ?? new Set([...preparationTargets].filter(([, target]) => target.prepareDrop?.() !== false).map(([number]) => number));
+  const seed = sessionDecisionCalibration(args.db, args.sessionId);
+  return candidates.reduce((total, tag) => {
+    if (preparationTargets.has(tag.tagNumber) && !prepared.has(tag.tagNumber))
+      return total;
+    const ratio = tag.type === "tool" ? seed.toolsRatio : seed.proseRatio;
+    return total + Math.max(0, (tag.tokenCount ?? Math.ceil(tag.byteSize / 4)) * ratio);
+  }, 0);
+}
+function originateExecuteReclaim(args) {
+  if (failedWrites.get(args.db)?.has(args.sessionId))
+    return false;
+  const state = readExecuteReclaimState(args.db, args.sessionId);
+  const heldPasses = args.primaryExecute && args.reclaimableTokens > 0 && !args.alreadyBusting ? state.heldPasses + 1 : 0;
+  if (!writeExecuteReclaimState(args.db, args.sessionId, { heldPasses }))
+    return false;
+  return args.primaryExecute && !args.alreadyBusting && !args.summaryCanCome && args.reclaimableTokens > 0 && (args.usableWindow > 0 && args.reclaimableTokens >= args.usableWindow * 0.02 || heldPasses >= 3);
+}
+
 // src/hooks/magic-context/historian-drain-gate.ts
 var loggedWindows = new WeakMap;
 function isHistorianDrainBudgetSpent(args) {
@@ -5982,7 +6428,7 @@ function resolveBoundaryContextLimit(usage, fallbackContextLimit) {
   }
   return 128000;
 }
-function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0) {
+function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0, liftLivePromptFloor = false) {
   return withRawSessionMessageCache2(() => {
     try {
       const memoryPrimed = inMemoryTail ? primeInMemoryTailRawMessageCache2({
@@ -6012,7 +6458,8 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         executeThresholdPercentage,
         usage,
         usageSource: "live",
-        taggerFloor
+        taggerFloor,
+        liftLivePromptFloor
       });
       const hasProtectedEligibleHead = boundary.offset < Math.min(boundary.protectedTailStart, boundary.eligibleEndOrdinal);
       if (!hasProtectedEligibleHead) {
@@ -6048,7 +6495,10 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
 function formatProjectedPostDropPercentage(value) {
   return value === null ? "none" : `${value.toFixed(1)}%`;
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds, primaryExecute = false) {
+  if (usage.percentage < executeThresholdPercentage) {
+    writeExecuteReclaimState(db, sessionId, { floorOrdinal: null, floorPromptId: null });
+  }
   if (sessionMeta.compartmentInProgress) {
     sessionLog2(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -6101,7 +6551,22 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       resolvedInMemoryTail = undefined;
     }
   }
-  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
+  let tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
+  const markState = readExecuteReclaimState(db, sessionId);
+  const mark = markState.floorOrdinal;
+  const livePromptOrdinal = tailInfo.boundarySnapshot?.diagnostics?.livePromptFloor.ordinal;
+  let consumedFloorMark = false;
+  if (mark !== null) {
+    const consumed = writeExecuteReclaimState(db, sessionId, {
+      floorOrdinal: null,
+      floorPromptId: null
+    });
+    if (consumed && mark === livePromptOrdinal && markState.floorPromptId === tailInfo.boundarySnapshot?.diagnostics?.livePromptFloor.messageId && usage.percentage >= executeThresholdPercentage) {
+      consumedFloorMark = true;
+      sessionLog2(sessionId, `compartment trigger: live-prompt floor mark consumed at ${mark}`);
+      tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor, true);
+    }
+  }
   if (!tailInfo.hasNewRawHistory) {
     try {
       const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
@@ -6185,7 +6650,21 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   if (!tailInfo.hasProtectedEligibleHead || !tailInfo.isMeaningful) {
-    sessionLog2(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% because unsummarized tail from ${tailInfo.nextStartOrdinal} is too small`);
+    let floorOnly = false;
+    const boundary = tailInfo.boundarySnapshot;
+    const floor = boundary?.diagnostics?.livePromptFloor;
+    if (!consumedFloorMark && floor?.ordinal && floor.from > floor.to) {
+      const withoutFloor = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor, true);
+      floorOnly = withoutFloor.hasProtectedEligibleHead && withoutFloor.isMeaningful;
+      if (floorOnly && primaryExecute && usage.percentage >= executeThresholdPercentage && writeExecuteReclaimState(db, sessionId, {
+        floorOrdinal: floor.ordinal,
+        floorPromptId: floor.messageId ?? null
+      })) {
+        sessionLog2(sessionId, `compartment trigger: live-prompt floor mark set at ${floor.ordinal}`);
+      }
+    }
+    const refusal = floorOnly ? `no eligible head (live-prompt floor at ${floor?.ordinal})` : tailInfo.hasProtectedEligibleHead ? "below meaningfulness" : "no eligible head";
+    sessionLog2(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% — ${refusal}; offset=${tailInfo.nextStartOrdinal} protectedStart=${boundary?.protectedTailStart ?? "none"} eligibleEnd=${boundary?.eligibleEndOrdinal ?? "none"} rawTokens=${tailInfo.trueRawEligibleTokens} chunkTokens=${tailInfo.tokenEstimate}`);
     return { shouldFire: false };
   }
   sessionLog2(sessionId, `compartment trigger: proactive fire at ${usage.percentage.toFixed(1)}% (floor=${proactiveTriggerPercentage}% projected post-drop=${formatProjectedPostDropPercentage(projectedPostDropPercentage)} target=${relativePostDropTarget.toFixed(1)}%)`);
@@ -6438,7 +6917,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
     evaluable: state.evaluable,
     generationInvalidated: state.generationInvalidated
   });
-  sessionLog2(sessionId, formatChannel1Evaluation(decision));
+  logNudgeEvaluation(sessionId, "tool-completion", formatChannel1Evaluation(decision));
   setLastNudgeUndropped(args.db, sessionId, decision.nextLastNudge);
   const nextNudgeState = {
     ...nudgeState,
@@ -6695,6 +7174,9 @@ function latestAssistantTurnStart(messages) {
 function latestAssistantTurnMessages(messages) {
   return new Set(messages.slice(latestAssistantTurnStart(messages)));
 }
+function isAnthropicThinkingPart(part, familyRoute) {
+  return isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic));
+}
 function hasActiveAnthropicThinkingTurn(messages, provider, model) {
   const familyRoute = isAnthropicFamilyRoute(provider, model);
   for (const message of messages.slice(latestAssistantTurnStart(messages))) {
@@ -6703,7 +7185,7 @@ function hasActiveAnthropicThinkingTurn(messages, provider, model) {
     const parts = content(message);
     if (!Array.isArray(parts))
       continue;
-    if (parts.some((part) => isRecord(part) && THINKING_TYPES.has(String(part.type ?? part.kind)) && (familyRoute || isRecord(part.metadata) && isRecord(part.metadata.anthropic))))
+    if (parts.some((part) => isAnthropicThinkingPart(part, familyRoute)))
       return true;
   }
   return false;
@@ -7040,96 +7522,26 @@ function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, execu
 }
 
 // src/features/magic-context/storage-host-instruction-retention.ts
-var NAMESPACE = "hostInstructionRetention";
+var NAMESPACE2 = "hostInstructionRetention";
 var enabled = true;
 function hostInstructionRetentionEnabled() {
   return enabled;
 }
 function isHostInstructionRetentionOn(db, sessionId) {
-  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE];
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE2];
   return typeof lane === "object" && lane !== null && lane.on === true;
 }
 function markHostInstructionRetention(db, sessionId) {
   return updateReplayDocument(db, sessionId, (doc) => {
-    const lane = doc[NAMESPACE];
+    const lane = doc[NAMESPACE2];
     if (typeof lane === "object" && lane !== null && lane.on === true)
       return false;
     doc.version = 2;
-    doc[NAMESPACE] = { on: true };
+    doc[NAMESPACE2] = { on: true };
     return true;
   });
 }
 
-// src/hooks/magic-context/pending-drop-eligibility.ts
-function pendingDropVeto(tagNumber, target, protectedTagIds) {
-  if (protectedTagIds.has(tagNumber))
-    return "protected";
-  if (target?.thinkingDropProtected)
-    return "active_thinking";
-  return null;
-}
-function capturePendingDropEligibility(targets, protectedTagIds) {
-  const eligible = new Set;
-  for (const [number, target] of targets) {
-    if (pendingDropVeto(number, target, protectedTagIds))
-      continue;
-    if (target.drop) {
-      if (target.canDrop?.() === true)
-        eligible.add(number);
-    } else {
-      const content = target.getContent?.();
-      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length)
-        eligible.add(number);
-    }
-  }
-  return eligible;
-}
-function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
-  const digests = input.map((message) => message.contentDigest?.() ?? null);
-  if (digests.some((digest) => digest === null))
-    return null;
-  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
-  if (!revision?.value)
-    return null;
-  return JSON.stringify([
-    input.map((message, index) => [
-      message.id,
-      message.role,
-      message.synthetic,
-      digests[index]
-    ]),
-    revision.value,
-    readEpochFloorSnapshot(db, sessionId),
-    sessionDecisionCalibration(db, sessionId).toolsRatio,
-    loadProtectedTailMeta(db, sessionId),
-    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
-    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
-    protectionInputs
-  ]);
-}
-function createPendingDropEligibilityCache() {
-  const sessions = new Map;
-  return {
-    read(sessionId, key) {
-      const previous = sessions.get(sessionId);
-      if (key === null || previous?.key !== key) {
-        sessions.delete(sessionId);
-        return;
-      }
-      return previous.eligible;
-    },
-    record(sessionId, key, eligible) {
-      sessions.delete(sessionId);
-      if (key === null)
-        return;
-      const oldest = sessions.keys().next().value;
-      if (sessions.size >= 64 && oldest !== undefined)
-        sessions.delete(oldest);
-      sessions.set(sessionId, { key, eligible: new Set(eligible) });
-    }
-  };
-}
-
 // src/hooks/magic-context/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
@@ -7415,12 +7827,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               }
             } else if (target) {
               const replacement = buildReplacementContent(pendingOp.tagId);
+              if (target.canSetContent?.(replacement) === false) {
+                reject("content_unchanged");
+                continue;
+              }
               persistDrop();
               mutations.push(() => {
                 const priorContent = target.getContent?.();
                 const changed = target.setContent(replacement);
-                record(changed);
                 if (changed) {
+                  record(true);
                   const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
                   onTagReduced?.({
                     tagNumber: pendingOp.tagId,
@@ -7683,14 +8099,14 @@ function foldExecutesThisPass(foldDue, materialized) {
 }
 
 // src/features/magic-context/storage-caveman-rules.ts
-var NAMESPACE2 = "caveman";
+var NAMESPACE3 = "caveman";
 var CURRENT_RULES_VERSION = 2;
 var ORIGINAL_RULES = {
   currentRules: false,
   englishWordRules: true,
   legacyReasoningTags: new Set
 };
-function parseState(lane) {
+function parseState2(lane) {
   if (!isRecord(lane) || lane.rules !== CURRENT_RULES_VERSION)
     return ORIGINAL_RULES;
   const tags = Array.isArray(lane.legacyReasoningTags) ? lane.legacyReasoningTags : [];
@@ -7702,7 +8118,7 @@ function parseState(lane) {
 }
 function getCavemanReplayState(db, sessionId) {
   try {
-    return parseState(readReplayEnvelope(db, sessionId)[NAMESPACE2]);
+    return parseState2(readReplayEnvelope(db, sessionId)[NAMESPACE3]);
   } catch (error) {
     if (error instanceof ReplayDocumentError)
       return ORIGINAL_RULES;
@@ -7712,11 +8128,11 @@ function getCavemanReplayState(db, sessionId) {
 function recordCavemanCurrentRules(db, sessionId, englishWordRules, legacyReasoningTags) {
   const tags = [...new Set(legacyReasoningTags)].sort((a, b) => a - b);
   const persisted = updateReplayDocument(db, sessionId, (doc) => {
-    const current = parseState(doc[NAMESPACE2]);
+    const current = parseState2(doc[NAMESPACE3]);
     if (current.currentRules && current.englishWordRules === englishWordRules)
       return false;
     doc.version = 2;
-    doc[NAMESPACE2] = {
+    doc[NAMESPACE3] = {
       rules: CURRENT_RULES_VERSION,
       legacyReasoningTags: current.currentRules ? [...current.legacyReasoningTags].sort((a, b) => a - b) : tags,
       ...englishWordRules ? {} : { englishWordRules: false }
@@ -8200,70 +8616,6 @@ function isVisibleNoteReadPart(part) {
   return false;
 }
 
-// src/hooks/magic-context/postprocess-read-cache.ts
-var connections = new WeakMap;
-function snapshot(db, sessionId) {
-  const transaction = db;
-  try {
-    if (transaction.inTransaction || transaction.isTransaction) {
-      connections.delete(db);
-      return { version: -1, changes: -1 };
-    }
-  } catch {
-    connections.delete(db);
-    return { version: -1, changes: -1 };
-  }
-  let connection = connections.get(db);
-  if (!connection) {
-    connection = {
-      stamp: db.prepare("SELECT total_changes() AS changes, data_version AS version FROM pragma_data_version"),
-      sessions: new BoundedSessionMap(100)
-    };
-    connections.set(db, connection);
-  }
-  const stamp = connection.stamp.get();
-  const previous = connection.sessions.get(sessionId);
-  if (previous?.version === stamp.version && previous.changes === stamp.changes) {
-    return previous;
-  }
-  const value = { ...stamp };
-  connection.sessions.set(sessionId, value);
-  return value;
-}
-function postprocessTailTags(db, sessionId) {
-  const state = snapshot(db, sessionId);
-  return state.tags ??= getTailHygieneTags2(db, sessionId);
-}
-function postprocessOldestTags(db, sessionId, protectedNumbers) {
-  const state = snapshot(db, sessionId);
-  const hints = state.hints;
-  if (hints && hints.protectedNumbers.size === protectedNumbers.size && [...protectedNumbers].every((number) => hints.protectedNumbers.has(number))) {
-    return hints.value;
-  }
-  const value = getOldestActiveUnprotectedToolTags2(db, sessionId, protectedNumbers);
-  state.hints = { protectedNumbers: new Set(protectedNumbers), value };
-  return value;
-}
-function postprocessReplaySnapshot(db, sessionId) {
-  const state = snapshot(db, sessionId);
-  const replay = state.replay ??= loadPostprocessReplaySnapshot(db, sessionId);
-  return {
-    ...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),
-    trailingBlankDecisions: new Map(replay.trailingBlankDecisions),
-    noteNudgeAnchors: structuredClone(replay.noteNudgeAnchors),
-    autoSearchHintDecisions: structuredClone(replay.autoSearchHintDecisions),
-    todoSyntheticAnchor: structuredClone(replay.todoSyntheticAnchor),
-    pendingCompactionMarker: structuredClone(replay.pendingCompactionMarker),
-    compactionMarker: structuredClone(replay.compactionMarker)
-  };
-}
-
 // src/hooks/magic-context/strict-thinking-prefix.ts
 function servedPrefixMatches(args) {
   const heads = args.messages?.slice(0, 2);
@@ -9054,7 +9406,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         const textPart = part;
         const thinkingParts = messageThinkingParts;
         const contentId = `${messageId}:p${partIndex}`;
-        const whitespaceOnlyAssistant = message.info.role === "assistant" && stripTagPrefix(textPart.text).trim().length === 0;
+        const whitespaceOnlyAssistant = message.info.role === "assistant" && (stripTagPrefix(textPart.text).trim().length === 0 || textPart.text.includes("§") && stripPersistedAssistantText(textPart.text).length === 0);
         let existingTagId;
         if (whitespaceOnlyAssistant) {
           const persistedWhitespaceTag = getTagNumberByMessageId2(db, sessionId, contentId);
@@ -9106,7 +9458,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         accAssignTag += performance.now() - _tAssignText;
         const persistedSource = sourceContents.get(tagId);
         if (persistedSource !== undefined && !options.refreshSourceContents) {
-          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource) : persistedSource;
+          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource, message.info.providerID) : persistedSource;
         } else {
           const sourceContent = stripTagPrefix(textPart.text);
           if (sourceContent.trim().length > 0 || options.refreshSourceContents) {
@@ -9135,6 +9487,10 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           dropReasoningParts: thinkingParts,
           mutationParts: [{ message, part: textPart }],
           textPrefix: skipPrefixInjection ? "" : prependTag(tagId, ""),
+          canSetContent: (content) => {
+            const partialEnd = messageId ? getPartialEnds().get(messageId) : undefined;
+            return textPart.text !== content && (partialEnd === undefined || partIndex <= partialEnd);
+          },
           setContent: (content, options) => {
             if (textPart.text === content)
               return false;
@@ -9437,6 +9793,25 @@ function proactiveStripStartIndex(args) {
     return divergence;
   return divergence ?? lastServed.messages.length;
 }
+function servesThinkingBlock(messages, providerID, modelID) {
+  const familyRoute = isAnthropicFamilyRoute(providerID, modelID);
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (const part of message.parts) {
+      if (!isAnthropicThinkingPart(part, familyRoute) || part.ignored === true)
+        continue;
+      if (part.type === "redacted_thinking")
+        return true;
+      if (typeof part.text === "string" && part.text !== "")
+        return true;
+      const records = isRecord(part.metadata) ? Object.values(part.metadata) : [];
+      if (records.some((record) => isRecord(record) && record.redactedData !== undefined))
+        return true;
+    }
+  }
+  return false;
+}
 function isPartDroppedBeforeWire(part, providerID) {
   if (!modelAcceptsEmptyContent(providerID) || !isRecord(part))
     return false;
@@ -9966,6 +10341,9 @@ async function runPostTransformPhase(args) {
     }
   };
   const trailingBlankSourceDecisions = args.trailingBlankSourceDecisions ?? snapshotTrailingBlankSourceDecisions(args.messages);
+  if (!modelAcceptsEmptyContent(args.resolvedProviderID) && !compactionOff)
+    captureInlineThinkingRepairs(args.messages, args.messageTagNumbers, args.sessionMeta?.clearedReasoningThroughTag ?? 0);
+  const servedShapeRepair = prepareServedShapeRepair(args.db, args.sessionId, args.messages, args.readLastServedMessages, compactionOff ? undefined : postprocessReplaySnapshot(args.db, args.sessionId));
   let trailingBlankNewestAssistant;
   for (let index = args.messages.length - 1;index >= 0; index -= 1) {
     const message = args.messages[index];
@@ -9995,8 +10373,8 @@ async function runPostTransformPhase(args) {
   }
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
-  let deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
-  let materializationRequested = isExplicitFlush || deferredMaterialize;
+  let deferredMaterialize = (args.canConsumeDeferredLate || servedShapeRepair.needsRebuild) && deferredMaterializationWasPending;
+  let materializationRequested = isExplicitFlush || deferredMaterialize || servedShapeRepair.needsRebuild;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
   const frozenThinking = new Set(args.activeThinkingTurn || compactionOff ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
   const compactionOffFrozenThinking = compactionOff ? compactionOffFrozenThinkingIds(frozenThinking) : new Set;
@@ -10039,6 +10417,8 @@ async function runPostTransformPhase(args) {
     if (stripOffWire)
       for (const id of stripped.strip?.messageIds ?? [])
         compactionOffFrozenThinking.add(id);
+    for (const id of stripped.strip?.messageIds ?? [])
+      bindingThinking.add(id);
     retainedThinking.clear();
     protectedThinkingMessages.clear();
     activeThinkingTurn = false;
@@ -10048,9 +10428,15 @@ async function runPostTransformPhase(args) {
     rewritingSignedPrefix = true;
     thinkingReleasedForFit ||= forFit;
   };
+  if (servedShapeRepair.needsRebuild && activeThinkingTurn)
+    releaseThinkingForRewrite(false, true);
   if (args.forceSignedRebuildForFit && (activeThinkingPrefixHold || activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true)) {
     releaseThinkingForRewrite(true);
   }
+  if (args.compactionModeTransition === true && args.thinkingBindingRecoveryEnabledForModel === true) {
+    sessionLog2(args.sessionId, "compaction mode switch: stripping signed thinking");
+    releaseThinkingForRewrite(false, true);
+  }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -10075,7 +10461,7 @@ async function runPostTransformPhase(args) {
   let foldBustsServedPrefixThisPass = false;
   let publishedM1RefreshedThisPass = false;
   let prefixPreflightFailed = false;
-  const softRefreshOpportunity = !freezeM0M1 && (args.schedulerDecision === "execute" || deferredMaterialize);
+  const softRefreshOpportunity = !freezeM0M1 && (args.schedulerDecision === "execute" || deferredMaterialize || servedShapeRepair.needsRebuild);
   let m0RematerializedThisPass = false;
   const m0CoverageBeforeFold = args.sessionMeta.cachedM0Bytes === null ? -1 : args.sessionMeta.cachedM0MaxCompartmentSeq;
   let m0MaterializeReason = null;
@@ -10090,6 +10476,7 @@ async function runPostTransformPhase(args) {
   };
   if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
+    let committedFoldChangesHead;
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
       const foldResult = injectM0M1({
@@ -10119,6 +10506,12 @@ async function runPostTransformPhase(args) {
               m1Text: rendered.m1Bytes.toString(),
               muralDataUrl: rendered.muralDataUrl
             }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            committedFoldChangesHead = firstRenderBust ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString(),
+              muralDataUrl: rendered.muralDataUrl
+            }) : foldChangesServedPrefix(servedPrefixBeforeFold, rendered);
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -10137,6 +10530,9 @@ async function runPostTransformPhase(args) {
       preparedPrefix = foldResult;
       if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
         releaseThinkingForRewrite(false, true);
+      } else if (compactionOff && !activeThinkingPrefixHold && args.thinkingBindingRecoveryEnabledForModel === true && committedFoldChangesHead) {
+        sessionLog2(args.sessionId, "compaction-off fold changed the head: stripping signed thinking");
+        releaseThinkingForRewrite(false, true);
       }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
@@ -10194,21 +10590,43 @@ async function runPostTransformPhase(args) {
   const heldIdleExpiryRebuild = activeThinkingPrefixHold && args.m0M1?.hardSignals?.cacheExpired === true;
   const idleExpiryRebuild = (!freezeM0M1 || activeThinkingPrefixHold) && args.m0M1?.hardSignals?.cacheExpired === true;
   const rideSignals = {
+    servedShapeRepair: servedShapeRepair.needsRebuild,
+    executeReclaim: false,
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: rewritingSignedPrefix || foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || args.contextUsageFromEstimate !== true && getEmergencyInputSample(args.db, args.sessionId) === 0),
     explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
     publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
   };
-  const publishedWorkDrainAllowed = !compactionOff && reclaimRidePermitted(rideSignals, {
+  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
+  rideSignals.executeReclaim = !compactionOff && originateExecuteReclaim({
+    db: args.db,
+    sessionId: args.sessionId,
+    primaryExecute: args.fullFeatureMode && args.schedulerDecision === "execute" && args.contextUsage.percentage < args.forceMaterializationPercentage,
+    alreadyBusting: Object.values(rideSignals).some(Boolean) || args.historyRebuiltThisPass,
+    summaryCanCome: compartmentRunning || args.sessionMeta.compartmentInProgress || (prefixPreflightFailed || freezeM0M1 || activeThinkingPrefixHold) && (args.deferredHistoryRefreshSessions.has(args.sessionId) || args.deferredMaterializationSessions.has(args.sessionId) || args.historyRefreshSessions?.has(args.sessionId) === true) || readExecuteReclaimState(args.db, args.sessionId).floorOrdinal !== null,
+    reclaimableTokens: estimateExecuteReclaimTokens({
+      db: args.db,
+      sessionId: args.sessionId,
+      pendingOps,
+      tags: args.tags,
+      targets: newTargets,
+      protectedTagIds: new Set([...args.protectedTagIds, ...protectedToolTags])
+    }),
+    usableWindow: args.usableWindow
+  });
+  const publishedWorkDrainAllowed = (!compactionOff || servedShapeRepair.needsRebuild) && reclaimRidePermitted(rideSignals, {
     signedThinkingHold: activeThinkingPrefixHold,
     firstRender: firstRenderBust,
     idleExpiry: idleExpiryRebuild,
     emergency: emergencyDropEligible
   });
-  const shouldApplyPendingOps = publishedWorkDrainAllowed;
-  const shouldRunHeuristics = publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldApplyPendingOps = !compactionOff && publishedWorkDrainAllowed;
+  const shouldRunHeuristics = !compactionOff && publishedWorkDrainAllowed && (rideSignals.publishedHistory || rideSignals.executeReclaim || rideSignals.servedShapeRepair || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  if (servedShapeRepair.needsRebuild && !isCacheBustingPass)
+    throw new Error("Served-shape repair requires a rebuilding pass");
+  servedShapeRepair.apply(isCacheBustingPass);
   let unheldSignedTurnBust = false;
   if (isCacheBustingPass && !activeThinkingPrefixHold && activeThinkingTurn && args.thinkingBindingRecoveryEnabledForModel === true) {
     if (foldBustsServedPrefixThisPass || firstRenderBust || publishedM1RefreshedThisPass)
@@ -10299,17 +10717,28 @@ async function runPostTransformPhase(args) {
       throw new EmergencyFailClosedError("Magic Context could not read its saved reasoning-removal state for this session", { cause: error });
     }
   }
+  const heuristicsLogChanged = diagnosticStateChanged(args.sessionId, "heuristics", JSON.stringify([
+    args.currentTurnId,
+    shouldRunHeuristics,
+    shouldRunHeuristics ? null : args.schedulerDeferReason
+  ]));
+  const pendingLogChanged = diagnosticStateChanged(args.sessionId, "pending-ops", JSON.stringify([
+    args.currentTurnId,
+    shouldApplyPendingOps,
+    shouldApplyPendingOps ? null : args.schedulerDeferReason,
+    shouldApplyPendingOps ? null : (getPendingOpsCount(args.db, args.sessionId) ?? 0) > 0
+  ]));
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
     const reason = isExplicitFlush ? `pending_materialization origin=${pendingOrigin}` : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `${reclaimRideLabel(rideSignals)} subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog2(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
-  } else if (args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  } else if (heuristicsLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog2(args.sessionId, `heuristics WILL NOT RUN — reason=${args.schedulerDeferReason}`);
   }
   if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
     sessionLog2(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
-  if (!shouldApplyPendingOps && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  if (!shouldApplyPendingOps && pendingLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog2(args.sessionId, `pending ops WILL NOT APPLY — reason=${args.schedulerDeferReason} pendingOps=${formatPendingOpsDepth()} context=${args.contextUsage.percentage.toFixed(1)}%`);
   }
   if (hasPendingUserOps && !shouldApplyPendingOps) {
@@ -10318,7 +10747,6 @@ async function runPostTransformPhase(args) {
   let explicitMaterializedSuccessfully = false;
   let deferredMaterializedSuccessfully = false;
   let pendingOpsDidMutate = false;
-  const protectedToolTags = protectedToolTagNumbers(args.tags, args.protectedTools);
   const firstApplicationEdits = { any: false, beforeNewerThinking: false };
   const recordFirstApplicationWireEdit = (beforeNewerThinking) => {
     firstApplicationEdits.any = true;
@@ -10326,6 +10754,8 @@ async function runPostTransformPhase(args) {
   };
   if (temporalFirstApplication)
     recordFirstApplicationWireEdit(true);
+  if (servedShapeRepair.needsRebuild)
+    recordFirstApplicationWireEdit(true);
   const firstApplicationLocations = new Map;
   const recordFirstApplicationAt = (message, partIndex) => {
     recordFirstApplicationWireEdit(false);
@@ -10468,11 +10898,12 @@ async function runPostTransformPhase(args) {
       if (routineCleanupApplied && canUseEmptySentinels) {
         stripClearedReasoning(args.messages);
       }
-      const strippedInline = routineCleanupApplied && ageLaneAllowed ? stripInlineThinking(args.messages, args.messageTagNumbers, budgetCutoff) : 0;
+      const strippedInline = routineCleanupApplied && ageLaneAllowed ? stripInlineThinking(args.messages, args.messageTagNumbers, budgetCutoff, !canUseEmptySentinels) : 0;
       const persistedInlineWatermark = args.sessionMeta?.clearedReasoningThroughTag ?? 0;
       if (routineCleanupApplied && persistedInlineWatermark > 0 && !compactionOff) {
-        replayStrippedInlineThinking(args.messages, args.messageTagNumbers, persistedInlineWatermark);
+        replayStrippedInlineThinking(args.messages, args.messageTagNumbers, persistedInlineWatermark, !canUseEmptySentinels);
       }
+      servedShapeRepair.apply(isCacheBustingPass);
       let removedReasoningMessages = 0;
       if (routineCleanupApplied && !prefixBoundModel && reasoningRemovalSelectable && reasoningRemovalReadable) {
         const newIds = selectReasoningRemovals({
@@ -10799,7 +11230,7 @@ async function runPostTransformPhase(args) {
       }
     }
     if (isCacheBustingPass) {
-      const droppedResult = stripDroppedPlaceholderMessages(args.messages, args.resolvedProviderID, recordFirstApplicationAt);
+      const droppedResult = stripDroppedPlaceholderMessages(args.messages.filter((message) => !servedShapeRepair.messageIDs.has(message.info.id ?? "")), args.resolvedProviderID, recordFirstApplicationAt);
       const protectedTailStart = Math.max(0, args.messages.length - SYSTEM_INJECTION_ACTIONABLE_TAIL_MESSAGES);
       const systemInjectedResult = stripSystemInjectedMessages(args.messages, protectedTailStart, args.resolvedProviderID, recordFirstApplicationAt);
       const hiddenMessages = args.hiddenMessagesAtCompactionSeam ?? [];
@@ -11399,6 +11830,8 @@ async function runPostTransformPhase(args) {
     });
   }
   logTransformTiming(args.sessionId, "pp.tailGuard", tTailGuard);
+  if (bustedThisPass)
+    clearExecuteReclaimState(args.db, args.sessionId);
   return {
     explicitMaterializedSuccessfully,
     deferredMaterializedSuccessfully,
@@ -11419,8 +11852,7 @@ async function runPostTransformPhase(args) {
     prefixTrimStatus: deliveredPrefix?.prefixTrimStatus ?? null,
     thinkingBindingRecovery,
     proactiveThinkingStrip,
-    thinkingReleasedForFit,
-    openTurnSignedThinkingKept: args.thinkingBindingRecoveryEnabledForModel === true && activeThinkingTurn && !rewritingSignedPrefix
+    thinkingReleasedForFit
   };
 }
 function checkM0MutationDriftAndSignal(args) {
@@ -11520,6 +11952,35 @@ function describeSystemPromptChange(previous, current) {
   return `presetChanged=${previous ? previous.preset !== current.preset : "unknown"} elements=[${elements.join("; ")}]`;
 }
 
+// src/hooks/magic-context/system-prompt-sticky-date.ts
+var STICKY_DATE_KEY = "systemPromptStickyDate";
+function readPersistedSystemPromptStickyDate(db, sessionId) {
+  try {
+    const saved = readReplayEnvelope(db, sessionId, "read")[STICKY_DATE_KEY];
+    return typeof saved === "string" && saved.length > 0 ? saved : undefined;
+  } catch (error) {
+    sessionLog2(sessionId, "system prompt sticky date record unreadable:", error);
+    return;
+  }
+}
+function persistSystemPromptStickyDate(db, sessionId, stickyDate) {
+  try {
+    const written = updateReplayDocument(db, sessionId, (doc) => {
+      if (doc[STICKY_DATE_KEY] === stickyDate)
+        return false;
+      doc.version = 2;
+      doc[STICKY_DATE_KEY] = stickyDate;
+      return true;
+    });
+    if (!written)
+      sessionLog2(sessionId, "system prompt sticky date record not written");
+    return written;
+  } catch (error) {
+    sessionLog2(sessionId, "system prompt sticky date record write failed:", error);
+    return false;
+  }
+}
+
 // src/hooks/magic-context/system-date-refresh.ts
 var channels = new WeakMap;
 var outputUpdates = new WeakMap;
@@ -11683,6 +12144,15 @@ function createSystemPromptHashHandler(deps) {
   });
   const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
+  const recordedStickyDateBySession = new Map;
+  const recordedStickyDate = (sessionId) => {
+    let recorded = recordedStickyDateBySession.get(sessionId);
+    if (recorded === undefined) {
+      recorded = readPersistedSystemPromptStickyDate(deps.db, sessionId) ?? null;
+      recordedStickyDateBySession.set(sessionId, recorded);
+    }
+    return recorded ?? undefined;
+  };
   const diagnosticPrompts = new Map;
   const processSystemPrompt = async (input, output) => {
     const sessionId = input.sessionID;
@@ -11750,9 +12220,34 @@ function createSystemPromptHashHandler(deps) {
       return;
     const previousHash = sessionMetaEarly?.systemPromptHash ?? "";
     const hasPersistedHash = previousHash !== "" && previousHash !== "0";
-    if (!hasPersistedHash)
-      stickyDateBySession.delete(sessionId);
-    const stickyDate = stickyDateBySession.get(sessionId);
+    const prefixBoundModel = isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID);
+    let stickyDate = stickyDateBySession.get(sessionId);
+    if (!hasPersistedHash) {
+      const previous = stickyDate ?? recordedStickyDate(sessionId);
+      const live = systemPromptDates(liveSystemContent).live;
+      const fieldCount = (dates) => dates === undefined ? 0 : JSON.parse(dates).length;
+      stickyDate = (!modelKey || prefixBoundModel) && previous !== undefined && live !== undefined && fieldCount(previous) === fieldCount(live) ? previous : undefined;
+      if (stickyDate === undefined)
+        stickyDateBySession.delete(sessionId);
+      else
+        stickyDateBySession.set(sessionId, stickyDate);
+    }
+    if (stickyDate === undefined && hasPersistedHash) {
+      const recorded = recordedStickyDate(sessionId);
+      const live = systemPromptDates(liveSystemContent).live;
+      if (recorded !== undefined && live !== undefined && recorded !== live && systemPromptFingerprint(systemPromptDates(liveSystemContent, recorded).stable, promptSurface.preset) === previousHash) {
+        stickyDate = recorded;
+        stickyDateBySession.set(sessionId, recorded);
+        sessionLog2(sessionId, `system prompt date restored after restart: real=${live}, using=${recorded}`);
+      }
+    }
+    const setStickyDate = (value) => {
+      stickyDateBySession.set(sessionId, value);
+      if (value !== recordedStickyDate(sessionId)) {
+        if (persistSystemPromptStickyDate(deps.db, sessionId, value))
+          recordedStickyDateBySession.set(sessionId, value);
+      }
+    };
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
@@ -11760,13 +12255,12 @@ function createSystemPromptHashHandler(deps) {
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
     const signedThinkingKept = systemDateSignedThinkingKept(deps.historyRefreshSessions, dateRequest);
-    const idleDateMayAdvance = idleCacheExpired && signedThinkingKept !== true;
-    const prefixBoundModel = isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID);
+    const systemDateMayMove = (rewrite, keptSignedThinking) => (rewrite || idleCacheExpired) && keptSignedThinking !== true;
     let deferredDateRefresh = false;
     if (currentDate && stickyDate && currentDate !== stickyDate && (idleCacheExpired ? prefixBoundModel : isCacheBusting) && !contentOrPresetChanged && !requestMessagesFinal) {
       const liveElements = [...output.system];
       deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted, keptSignedThinking) => {
-        if (!permitted && !(idleCacheExpired && keptSignedThinking !== true)) {
+        if (!systemDateMayMove(permitted, keptSignedThinking)) {
           deps.systemPromptRefreshSessions.add(sessionId);
           return;
         }
@@ -11779,7 +12273,7 @@ function createSystemPromptHashHandler(deps) {
             cachedM0SystemHash: hash,
             systemPromptTokens: estimateTokens(content)
           });
-          stickyDateBySession.set(sessionId, currentDate);
+          setStickyDate(currentDate);
           output.system.splice(0, output.system.length, ...liveElements);
           publishSystemDateOutput(output.system);
           deps.systemPromptRefreshSessions.delete(sessionId);
@@ -11790,12 +12284,12 @@ function createSystemPromptHashHandler(deps) {
         }
       });
     }
-    const dateMayAdvance = idleDateMayAdvance && !deferredDateRefresh || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
+    const dateMayAdvance = contentOrPresetChanged || !deferredDateRefresh && systemDateMayMove(isCacheBusting && (dateRequest ? rewritePermission === true : rewritePermission !== false), signedThinkingKept);
     if (currentDate && !stickyDate) {
-      stickyDateBySession.set(sessionId, currentDate);
+      setStickyDate(currentDate);
     } else if (currentDate && stickyDate && currentDate !== stickyDate) {
       if (dateMayAdvance) {
-        stickyDateBySession.set(sessionId, currentDate);
+        setStickyDate(currentDate);
         sessionLog2(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
       } else {
         let offset = 0;
@@ -11853,7 +12347,7 @@ function createSystemPromptHashHandler(deps) {
         sessionLog2(sessionId, "system prompt meta persist failed (fail-open):", error);
       }
     }
-    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true)) {
+    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true && signedThinkingKept !== true)) {
       deps.systemPromptRefreshSessions.delete(sessionId);
     }
   };
@@ -11868,6 +12362,7 @@ function createSystemPromptHashHandler(deps) {
     handler,
     clearSession: (sessionId) => {
       diagnosticPrompts.delete(sessionId);
+      recordedStickyDateBySession.delete(sessionId);
       clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
@@ -18349,8 +18844,8 @@ async function runCompartmentPhaseImpl(args) {
     }
     return "completed";
   }
-  if (!historianRunnable && args.sessionMeta.compartmentInProgress) {
-    sessionLog2(args.sessionId, "transform: historian disabled; clearing stale compartmentInProgress flag");
+  if ((!historianRunnable || !args.canRunCompartments && !getActiveCompartmentRun(args.sessionId)) && args.sessionMeta.compartmentInProgress) {
+    sessionLog2(args.sessionId, "transform: historian unavailable; clearing stale compartmentInProgress flag");
     updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
     compartmentInProgress = false;
   }
@@ -18601,8 +19096,10 @@ function createTransform(deps) {
   const loadedSessions = new Set;
   const prefixHoldLogTurnIds = new Map;
   const thinkingFitRetries = new Set;
+  const compactionModeTransitionPending = new Set;
   const clearSessionLogState = (sessionId) => {
     prefixHoldLogTurnIds.delete(sessionId);
+    clearDiagnosticLogState(sessionId);
   };
   const unmanagedOverWindowSessions = new Set;
   const rustModeTransform = deps.transformMode === "rust" && deps.rustModeModuleClient ? createRustModeTransform(deps, {
@@ -18696,7 +19193,7 @@ function createTransform(deps) {
         failPass("store-generation-rebase-failure", error);
       }
     }
-    if (deps.client !== undefined) {
+    if (deps.client !== undefined || deps.hostMessageReconciliationSource !== undefined) {
       withoutSqliteTransformPass2(() => scheduleReconciliation(db, sessionId, host.hostMessageReconciliationSource));
     }
     const tUserMsg = performance.now();
@@ -18743,6 +19240,7 @@ function createTransform(deps) {
       const hasTransitionEffects = transition.recordToWrite !== null || transition.notice !== null || transition.invalidatedM0Baseline || transition.clearedCompartmentInProgress || transition.historianCatchUpSignaled;
       if (hasTransitionEffects) {
         if (transition.invalidatedM0Baseline) {
+          compactionModeTransitionPending.add(sessionId);
           sessionMeta = {
             ...sessionMeta,
             cachedM0Bytes: null,
@@ -19075,6 +19573,8 @@ function createTransform(deps) {
       contextLimit: boundaryContextLimit
     });
     let _boundarySnapshotCache;
+    if (fullFeatureMode && !compactionOff)
+      maintainExecuteFloorMark(db, sessionId, currentTurnId, boundaryUsageForProtectedTail.percentage < boundaryExecuteThreshold);
     const getRunnableBoundaryForCompartment = (emergencyTailScale) => {
       if (!canRunCompartments)
         return null;
@@ -19200,8 +19700,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       recordedSessionProjectIdentity.set(sessionId, sessionIdentityForBinding);
     }
     const taggerFloor = compactionOff ? 0 : deriveTaggerLoadFloor(messages, sessionId, db);
-    if (!compactionOff && taggerFloor === 0 && messages.length > 0) {
-      sessionLog2(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
+    const tagFloorMode = compactionOff || messages.length === 0 ? "inactive" : taggerFloor === 0 ? "fallback" : "scoped";
+    if (diagnosticStateChanged(sessionId, "tag-floor", tagFloorMode) && tagFloorMode !== "inactive") {
+      sessionLog2(sessionId, taggerFloor === 0 ? `tag floor: 0 (full-scan fallback) — no scoped floor above the safety margin across ${messages.length} msgs` : `tag floor: ${taggerFloor} (scoped load)`);
     }
     const ownerRatio = sessionDecisionCalibration(db, sessionId).proseRatio;
     noteTransformPassForExactOrdinalReads(sessionId);
@@ -19238,7 +19739,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
             idleExpiry: false,
             emergency: contextUsageEarly.percentage >= forceMaterializationPercentage
           }
-        }, pendingDropEligibility.read(sessionId, dropProjectionKey()));
+        }, pendingDropEligibility.read(sessionId, dropProjectionKey()), schedulerDecision === "execute");
         if (triggerResult.shouldFire) {
           sessionLog2(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
           updateSessionMeta(db, sessionId, { compartmentInProgress: true });
@@ -19392,7 +19893,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (persistedReasoningWatermark > 0 && !compactionOff) {
       const tReplay = performance.now();
       const replayed = canUseEmptySentinels ? replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark) : 0;
-      const replayedInline = replayStrippedInlineThinking(messages, messageTagNumbers, persistedReasoningWatermark);
+      const replayedInline = replayStrippedInlineThinking(messages, messageTagNumbers, persistedReasoningWatermark, !canUseEmptySentinels);
       if (replayed > 0 || replayedInline > 0) {
         sessionLog2(sessionId, `reasoning replay: cleared=${replayed} inlineStripped=${replayedInline} (watermark=${persistedReasoningWatermark})`);
       }
@@ -19609,6 +20110,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       activeThinkingPrefixHold,
       directoryPrefixHold: unresolvedDirectoryHold,
       forceSignedRebuildForFit: thinkingFitRetries.has(sessionId) || !!recovery.rebuildReason,
+      compactionModeTransition: compactionModeTransitionPending.has(sessionId),
       readLastServedMessages: () => {
         const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
         try {
@@ -19666,6 +20168,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         hardSignals: m0HardSignals
       }
     });
+    compactionModeTransitionPending.delete(sessionId);
     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] : []));
@@ -19843,7 +20346,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       if (JSON.stringify([...new Set(stillUntagged)].sort()) !== JSON.stringify([...new Set(persistedUntaggedInputIds)].sort()) && !persistLkgUntaggedInputIds(db, sessionId, stillUntagged))
         throw new Error("Cannot persist the last-good untagged-message record");
     }
-    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && postTransformResult.openTurnSignedThinkingKept !== true || postTransformResult.thinkingReleasedForFit === true, postTransformResult.openTurnSignedThinkingKept === true);
+    const signedThinkingServed = isPrefixBoundThinkingModel(modelForBudget?.providerID, modelForBudget?.modelID) && servesThinkingBlock(messages, modelForBudget?.providerID, modelForBudget?.modelID);
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && !signedThinkingServed || postTransformResult.thinkingReleasedForFit === true, signedThinkingServed);
     if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
       recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
     }
@@ -20001,7 +20505,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           postReduceGraceBaselineU: channel1State.postReduceGraceBaselineU,
           postReduceGracePreLevel: channel1State.postReduceGracePreLevel
         });
-        sessionLog2(sessionId, formatChannel1Evaluation(channel1Decision));
+        logNudgeEvaluation(sessionId, "transform", formatChannel1Evaluation(channel1Decision));
         const channel2Evaluation = evaluateChannel2(channelBaseline);
         const leaseBefore = getChannel2NudgeState(db, sessionId);
         if (channelBaseline.evaluable && !channelBaseline.generationInvalidated && !channelBaseline.reducedSinceRefresh) {
@@ -20012,7 +20516,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           }
         }
         const leaseAfter = getChannel2NudgeState(db, sessionId);
-        sessionLog2(sessionId, formatChannel2Evaluation(channel2Evaluation, {
+        logNudgeEvaluation(sessionId, "transform", formatChannel2Evaluation(channel2Evaluation, {
           leaseBefore,
           leaseAfter,
           gateHoldReason: channelBaseline.reducedSinceRefresh ? "recent-reduce-refresh" : undefined
@@ -21981,7 +22485,7 @@ function loadRegistrationConfig(directory) {
     configCache.delete(directory);
   return detailed;
 }
-async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
+async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db, options = {}) {
   const detailed = loadRegistrationConfig(directory);
   const projectIdentity = resolveProjectIdentityForSession(directory, detailed.config.allow_home_project);
   if (!projectIdentity)
@@ -22002,6 +22506,9 @@ async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
     memoryEnabled: detailed.config.memory.enabled,
     gitCommitEnabled: detailed.config.memory.git_commit_indexing.enabled
   };
+  if (options.preflightLocalPooling && routing.primary.provider === "local") {
+    await preflightLocalEmbeddingPooling(routing.primary.model ?? "Xenova/all-MiniLM-L6-v2");
+  }
   const before = getProjectEmbeddingSnapshot2(projectIdentity);
   const registered = registerProjectEmbedding2(db, projectIdentity, routing.primary, features, directory);
   if (!before || before.providerIdentity !== registered.providerIdentity || before.runtimeFingerprint !== registered.runtimeFingerprint)
@@ -22011,6 +22518,7 @@ async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
   } else {
     unregisterProjectShadowEmbedding2(projectIdentity);
   }
+  options.onRegistered?.(projectIdentity);
 }
 
 // src/hooks/magic-context/format-embed-failure.ts
@@ -22932,6 +23440,7 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
   const lkg = getLkgSlotHeapStats();
   const tagger = runtimeHolders.taggerCache ?? EMPTY_TAGGER_HEAP_STATS;
   const wire = runtimeHolders.wireCache ?? EMPTY_WIRE_HEAP_STATS;
+  const replay = runtimeHolders.generateReplay ?? { totalBytes: 0, sessions: [] };
   const messageIndexQueue = getMessageIndexQueueHeapStats();
   const sessions = new Map;
   const session = (sessionId) => {
@@ -22945,7 +23454,8 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
         wireRawMessages: 0,
         wireMessages: 0,
         wireContentSnapshots: 0,
-        wireEstimatedBytes: 0
+        wireEstimatedBytes: 0,
+        generateReplayBytes: 0
       };
       sessions.set(sessionId, current);
     }
@@ -22965,6 +23475,8 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
     target.wireContentSnapshots += entry.rawContentSnapshots;
     target.wireEstimatedBytes += entry.estimatedBytes;
   }
+  for (const entry of replay.sessions)
+    session(entry.sessionId).generateReplayBytes += entry.bytes;
   return {
     pid: process.pid,
     bunVersion: typeof Bun !== "undefined" && typeof Bun.version === "string" ? Bun.version : "unavailable",
@@ -22995,6 +23507,10 @@ function buildDebugMemoryUsage(runtimeHolders = {}) {
         estimatedBytes: wire.estimatedBytes
       },
       compartmentMirrors: { entries: 0 },
+      generateReplay: {
+        sessionCount: replay.sessions.length,
+        estimatedBytes: replay.totalBytes
+      },
       messageIndexQueue,
       sessions: [...sessions.values()].sort((a, b) => a.sessionId.localeCompare(b.sessionId))
     }
@@ -23211,9 +23727,9 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-2zh4gm2c.js"));
-    const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-nx97z3x7.js"));
-    const { userObservationCollectionEnabled, userObservationsRequested } = await importPluginModule(() => import("./task-config-nvz8mapa.js"));
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await importPluginModule(() => import("./derive-budgets-knf763tt.js"));
+    const { resolveHistorianModel } = await importPluginModule(() => import("./model-resolution-280gmqvd.js"));
+    const { userObservationCollectionEnabled, userObservationsRequested } = await importPluginModule(() => import("./task-config-7md27rx8.js"));
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 10 * 60 * 1000;
     const runConfig = historianRunConfig(config, currentPluginConfigReader(directory)?.poll().effective ?? config);
     const historianModel = resolveHistorianModel(runConfig, "opencode");
@@ -23244,7 +23760,7 @@ function registerRpcHandlers(rpcServer, args) {
       return { ok: false, error: "no session" };
     const readDirectory = args.readSessionDirectory;
     if (readDirectory) {
-      const { handoffHistoryWork } = await import("./history-owner-42e16w0n.js");
+      const { handoffHistoryWork } = await import("./history-owner-ad0crnrn.js");
       const handed = await handoffHistoryWork({
         storageDir: args.storageDir ?? getMagicContextStorageDir(),
         directory,
@@ -23263,8 +23779,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-f6m9jr7p.js"));
-    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-3pxn658x.js"));
+    const { runManagedRecomp } = await importPluginModule(() => import("./recomp-orchestrator-b12zaptj.js"));
+    const { sendIgnoredMessage } = await importPluginModule(() => import("./send-session-notification-8eqe259v.js"));
     log2(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -23322,7 +23838,7 @@ function registerRpcHandlers(rpcServer, args) {
   rpcServer.handle("wrapup", async (params) => {
     const readDirectory = args.readSessionDirectory;
     if (readDirectory && params.sessionId) {
-      const { handoffHistoryWork } = await import("./history-owner-42e16w0n.js");
+      const { handoffHistoryWork } = await import("./history-owner-ad0crnrn.js");
       const sessionId = String(params.sessionId);
       const handed = await handoffHistoryWork({
         storageDir: args.storageDir ?? getMagicContextStorageDir(),
@@ -23348,7 +23864,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-embdz8gj.js"));
+    const { runManagedWrapup } = await importPluginModule(() => import("./wrapup-orchestrator-3ssd5yy1.js"));
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -23433,8 +23949,17 @@ function subagentToolRefusal(db, toolId, sessionId, isInternalChild = () => fals
 function hideSubagentTools(draft, db) {
   if (!getOrCreateSessionMeta(db, draft.sessionID).isSubagent)
     return;
+  removePrimaryOnlyTools(draft.tools);
+}
+function removePrimaryOnlyTools(tools) {
   for (const id of PRIMARY_ONLY_TOOLS)
-    delete draft.tools[id];
+    delete tools[id];
+}
+function storedSubagentMode(db, sessionId) {
+  const row = db.prepare("SELECT is_subagent FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!row || typeof row.is_subagent !== "number")
+    return;
+  return row.is_subagent === 1;
 }
 
 // src/shared/conflict-detector.ts
@@ -24715,8 +25240,8 @@ function toolStateContent(state) {
 }
 
 // src/v2/hooks/copied-tag-notation.ts
-function stripCopiedTagNotation(text) {
-  return text.includes("§") ? stripPersistedAssistantText(text) : text;
+function stripCopiedTagNotation(text, acceptsEmpty = true) {
+  return text.includes("§") ? stripPersistedAssistantText(text, acceptsEmpty) : text;
 }
 
 // src/v2/hooks/payload.ts
@@ -24783,18 +25308,56 @@ function containsHostInstance(value) {
   return false;
 }
 function clonePreservingInstances(value) {
-  if (isHostInstance(value))
+  return cloneCounting(value, undefined);
+}
+function clonePreservingInstancesMeasured(value) {
+  const meter = { bytes: 0 };
+  const copy = cloneCounting(value, meter);
+  return { copy, bytes: meter.bytes };
+}
+function cloneCounting(value, meter) {
+  if (isHostInstance(value)) {
+    if (meter)
+      meter.bytes += instanceBytes(value, new WeakSet);
     return value;
-  if (Array.isArray(value))
-    return value.map(clonePreservingInstances);
+  }
+  if (Array.isArray(value)) {
+    if (meter)
+      meter.bytes += 16 + 8 * value.length;
+    return value.map((entry) => cloneCounting(entry, meter));
+  }
   if (value && typeof value === "object") {
     const copy = {};
-    for (const [key, entry] of Object.entries(value))
-      copy[key] = clonePreservingInstances(entry);
+    if (meter)
+      meter.bytes += 32;
+    for (const [key, entry] of Object.entries(value)) {
+      if (meter)
+        meter.bytes += 16;
+      copy[key] = cloneCounting(entry, meter);
+    }
     return copy;
   }
+  if (meter)
+    meter.bytes += typeof value === "string" ? 2 * value.length : 8;
   return value;
 }
+function instanceBytes(value, seen) {
+  if (typeof value === "string")
+    return 2 * value.length;
+  if (!value || typeof value !== "object")
+    return 8;
+  if (seen.has(value))
+    return 0;
+  seen.add(value);
+  if (ArrayBuffer.isView(value))
+    return value.byteLength;
+  if (value instanceof ArrayBuffer)
+    return value.byteLength;
+  let bytes = 32;
+  for (const entry of Object.values(value))
+    bytes += 16 + instanceBytes(entry, seen);
+  return bytes;
+}
 function contentKey(value) {
   const plain = (entry) => {
     if (ArrayBuffer.isView(entry)) {
@@ -24850,7 +25413,7 @@ function rebuildFileContent(value, output, attachments) {
     rebuilt.unshift({ type: "text", text: output });
   return { type: "content", value: rebuilt };
 }
-function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
+function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map, hiddenTimes = false) {
   const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
   const source = draft.messages.filter((m) => !existingHeads.has(m.id));
   const results = new Map;
@@ -24933,12 +25496,16 @@ function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
   const messages = [];
   for (const message of source) {
     const parts = [];
+    const copiedTagOnly = [];
     for (const content of message.content) {
       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.role === "assistant" && part.type === "text" && typeof part.text === "string") {
+        if (!modelAcceptsEmptyContent(draft.model.providerID) && part.text.trim().length > 0 && stripCopiedTagNotation(part.text).trim().length === 0)
+          copiedTagOnly.push({ index: parts.length, text: part.text });
+        part.text = stripCopiedTagNotation(part.text, modelAcceptsEmptyContent(draft.model.providerID));
+      }
       if (message.id && admittedIDs.has(message.id))
         part.synthetic = true;
       parts.push(part);
@@ -24969,7 +25536,18 @@ function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map) {
       },
       parts
     };
+    if (hiddenTimes && mapped.info.time !== undefined) {
+      const time = mapped.info.time;
+      delete mapped.info.time;
+      Object.defineProperty(mapped.info, "time", {
+        value: time,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    }
     originals.set(mapped, message);
+    markServedShapeRepair(mapped.info, copiedTagOnly);
     if (isCoveredInstructionRow(message))
       markCoveredInstructionRow(mapped.info);
     if (typeof message.id !== "string")
@@ -26469,10 +27047,12 @@ function assistantText(row) {
 
 class HiddenProviderError extends Error {
   settled;
+  hostError;
   constructor(detail, options = {}) {
     super(`Hidden completion provider error: ${detail}`);
     this.name = "HiddenProviderError";
     this.settled = options.settled ?? true;
+    this.hostError = options.hostError;
   }
 }
 function requestModel(request, current) {
@@ -26536,7 +27116,9 @@ async function awaitAssistantRow(openReader, readSessionError, localFailure, chi
           `terminal_row=${errorText(newIdle)}`,
           `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
         ];
-        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`, {
+          cause: sessionError
+        }) : new HiddenProviderError(details.join("; "), { hostError: sessionError });
       }
       if (outcome === "succeeded" && newAssistant)
         return newAssistant;
@@ -26550,7 +27132,9 @@ async function awaitAssistantRow(openReader, readSessionError, localFailure, chi
           `terminal_row=${errorText(newAssistant)}`,
           `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
         ];
-        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`, {
+          cause: sessionError
+        }) : new HiddenProviderError(details.join("; "), { hostError: sessionError });
       }
       if (newAssistant.data.error !== undefined) {
         throw new HiddenProviderError(errorText(newAssistant.data.error), {
@@ -26705,7 +27289,13 @@ async function createV2HiddenCompletionExecutor(host, options) {
         const head = await resolveHead(identity);
         const active = await lifecycle.open(identity, role, head);
         openedChild = active;
-        const handle = { id: active.id, childSessionId: active.id };
+        const configuredModel = toModelEntry(identity.model);
+        const handle = {
+          id: active.id,
+          childSessionId: active.id,
+          attemptedModel: modelKey(head),
+          ...configuredModel?.sourceConfigKey ? { modelConfigKey: configuredModel.sourceConfigKey } : {}
+        };
         const tokenBudget = identity.metadata?.tokenBudget;
         const run = {
           identity,
@@ -26736,6 +27326,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
       }
     },
     async attempt(handle, request) {
+      const startedAt = Date.now();
       const run = runs.get(handle);
       if (!run)
         throw new Error("Unknown hidden completion run");
@@ -26753,6 +27344,10 @@ async function createV2HiddenCompletionExecutor(host, options) {
         throw new Error("Hidden completion prompt aborted");
       }
       const requested = await validateVariant(requestModel(request, run.child.model));
+      const requestedRef = modelKey(requested);
+      const configuredModel = [run.identity.model, ...run.identity.configuredModels ?? []].map(toModelEntry).find((entry) => entry?.model === requestedRef);
+      handle.attemptedModel = requestedRef;
+      handle.modelConfigKey = configuredModel?.sourceConfigKey ?? handle.modelConfigKey;
       if (run.identity.kind !== "dreamer-task" && request.body.temperature === undefined) {
         const configured = options.historianTemperature?.();
         if (typeof configured === "number" && Number.isFinite(configured))
@@ -26847,6 +27442,22 @@ async function createV2HiddenCompletionExecutor(host, options) {
         abortReject = reject;
       });
       const onAbort = () => {
+        const reason = request.signal?.reason;
+        if (reason instanceof ModelProducedNoOutputError && run.identity.kind === "dreamer-task") {
+          recordChildInvocation({
+            db: options.db,
+            parentSessionId: run.identity.parentSessionId ?? options.projectIdentity,
+            parentInvocationId: run.identity.parentInvocationId,
+            harness: "opencode2",
+            subagent: "dreamer",
+            task: run.identity.title.replace(/^magic-context-dream-/, ""),
+            startedAt,
+            status: "timed_out",
+            error: reason,
+            providerId: requested.providerID,
+            modelId: requested.modelID
+          });
+        }
         interruptAndRetire(run, "prompt-aborted").finally(() => abortReject(new Error("Hidden completion prompt aborted")));
       };
       const deadlineTimer = setTimeout(() => {
@@ -26875,6 +27486,9 @@ async function createV2HiddenCompletionExecutor(host, options) {
         })
       };
       inFlight.add(entry);
+      const stopWatching = host.watchModelActivity?.(run.child.id, () => noteModelOutputReceived(request.signal));
+      if (stopWatching)
+        noteModelActivityMonitored(request.signal);
       try {
         await Promise.race([
           host.prompt({ sessionID: run.child.id, text: marker }),
@@ -26930,12 +27544,20 @@ async function createV2HiddenCompletionExecutor(host, options) {
           usage: reportedUsage ? usage : meter(system, promptText(request), text ?? ""),
           lengthCapped: ["length", "max_tokens"].includes(row.data.finish ?? ""),
           providerId: row.data.model?.providerID ?? requested.providerID,
-          modelId: row.data.model?.id ?? requested.modelID
+          modelId: row.data.model?.id ?? requested.modelID,
+          attemptedModel: requestedRef,
+          modelConfigKey: handle.modelConfigKey
         };
         if (!run.child.ever_settled)
           run.child = lifecycle.markEverSettled(run.child);
       } catch (caught) {
         const error = attempt.budgetExceeded ?? attempt.stepLimit ?? attempt.refusal ?? caught;
+        const hostError = error instanceof HiddenProviderError ? error.hostError : error instanceof Error && error.message.startsWith("Hidden completion failed:") ? error.cause : undefined;
+        annotateSubagentInvocationError(error, {
+          attemptedModel: handle.attemptedModel,
+          modelConfigKey: handle.modelConfigKey,
+          ...hostError === undefined ? {} : { hostError }
+        });
         run.failed = true;
         if (!(error instanceof HiddenProviderError)) {
           run.unsettledFailure = true;
@@ -26949,6 +27571,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
         }
         throw error;
       } finally {
+        stopWatching?.();
         clearTimeout(deadlineTimer);
         if (budgetPoll)
           clearInterval(budgetPoll);
@@ -27004,6 +27627,30 @@ async function createV2HiddenCompletionExecutor(host, options) {
   };
 }
 
+// src/v2/hidden-model-activity.ts
+class HiddenModelActivity {
+  watchers = new Map;
+  watch(sessionID, onOutput) {
+    this.watchers.set(sessionID, onOutput);
+    return () => {
+      if (this.watchers.get(sessionID) === onOutput)
+        this.watchers.delete(sessionID);
+    };
+  }
+  observe(event) {
+    if (!isRecord(event) || !isRecord(event.data))
+      return;
+    const { sessionID, delta, text } = event.data;
+    if (typeof sessionID !== "string")
+      return;
+    const streamed = ["session.text.delta", "session.reasoning.delta", "session.tool.input.delta"].includes(String(event.type)) && typeof delta === "string" && delta.length > 0;
+    const ended = ["session.text.ended", "session.reasoning.ended"].includes(String(event.type)) && typeof text === "string" && text.length > 0;
+    if (streamed || ended || event.type === "session.tool.input.started") {
+      this.watchers.get(sessionID)?.();
+    }
+  }
+}
+
 // src/v2/hooks/channel2.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 var pendingCandidates = new WeakMap;
@@ -27869,7 +28516,9 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         status: "completed",
         tokens: run.output.usage,
         providerId: run.output.providerId,
-        modelId: run.output.modelId
+        modelId: run.output.modelId,
+        attemptedModel: args.model,
+        configuredModels: args.fallbackModels
       });
     }
     stage = "apply";
@@ -28061,6 +28710,7 @@ async function runHiddenSingleShotPrompt(args) {
       });
   }).catch(() => {});
   const handle = await raceWithSignal(opening, args.signal);
+  let completion;
   args.onOpened?.(handle.id);
   let promptSettled = false;
   try {
@@ -28082,7 +28732,10 @@ async function runHiddenSingleShotPrompt(args) {
       ...args.signal ? { signal: args.signal } : {},
       fallbackModels: args.fallbackModels,
       callContext: args.callContext,
-      fetchOutput: () => args.executor.collect(handle, 50),
+      fetchOutput: async () => {
+        completion = await args.executor.collect(handle, 50);
+        return completion;
+      },
       validateOutput: (completion) => {
         const tokens = completion.tokenLog ?? runTokenLog(undefined);
         sessionLog2(args.parentSessionId ?? "dreamer", `${args.callContext} response_chars=${(completion.text ?? completion.reasoning ?? "").length} ${formatRunTokenLog(tokens)}`);
@@ -28098,6 +28751,12 @@ async function runHiddenSingleShotPrompt(args) {
     promptSettled = true;
     return { validated: run.validated, completion: run.output, childSessionId: handle.id };
   } catch (error) {
+    const configuredModel = toModelEntry(args.model);
+    annotateSubagentInvocationError(error, {
+      attemptedModel: completion?.attemptedModel ?? handle.attemptedModel ?? configuredModel?.model,
+      modelConfigKey: completion?.modelConfigKey ?? handle.modelConfigKey ?? configuredModel?.sourceConfigKey,
+      ...completion?.hostError === undefined ? {} : { hostError: completion.hostError }
+    });
     if (args.onFailureOutput) {
       let timer;
       try {
@@ -28425,6 +29084,8 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -29212,6 +29873,8 @@ function recordInvocation(args, startedAt, params) {
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     ...params.completion && !params.completion.messages ? {
       tokens: params.completion.usage,
       providerId: params.completion.providerId,
@@ -29527,28 +30190,35 @@ function diff(name, before, after) {
     rmSync2(dir, { recursive: true, force: true });
   }
 }
-function validateDocsProposal(projectDir, output, budget, expected) {
-  if (Object.entries(expected).some(([name, value]) => docsBaseHashes(projectDir)[name] !== value))
-    throw new Error("base drifted");
+function parseDocsProposalOutput(output) {
   const match = output.match(/```json\s*([\s\S]*?)```/);
   const parsed = JSON.parse(match?.[1] ?? output);
   if (!Array.isArray(parsed))
     throw new Error("proposal must be a JSON array");
   const changes = parsed;
-  if (!changes.length)
-    throw new Error("empty proposal");
   if (changes.some((item) => !item || !FILES.includes(item.file)))
     throw new Error("unknown proposal file");
+  const seen = new Set;
+  for (const change of changes) {
+    const key = `${change.file}:${change.heading}`;
+    if (!["replace", "add", "remove"].includes(change.action) || typeof change.heading !== "string" || !/^#{1,6} [^\r\n]+$/.test(change.heading) || typeof change.text !== "string" || typeof change.reason !== "string" || !change.reason.trim() || /[\r\n]/.test(change.reason) || seen.has(key))
+      throw new Error(`invalid section change in ${change.file}`);
+    seen.add(key);
+  }
+  return changes;
+}
+function validateDocsProposal(projectDir, output, budget, expected) {
+  if (Object.entries(expected).some(([name, value]) => docsBaseHashes(projectDir)[name] !== value))
+    throw new Error("base drifted");
+  const changes = parseDocsProposalOutput(output);
+  if (!changes.length)
+    throw new Error("empty proposal");
   let tokens = 0;
   let diffs = "";
   for (const file of FILES) {
     const before = existsSync4(join8(projectDir, file)) ? readFileSync6(join8(projectDir, file), "utf8") : "";
     let after = before;
-    const seen = new Set;
     for (const change of changes.filter((item) => item.file === file)) {
-      if (!["replace", "add", "remove"].includes(change.action) || typeof change.heading !== "string" || !/^#{1,6} [^\r\n]+$/.test(change.heading) || typeof change.text !== "string" || typeof change.reason !== "string" || !change.reason.trim() || /[\r\n]/.test(change.reason) || seen.has(change.heading))
-        throw new Error(`invalid section change in ${file}`);
-      seen.add(change.heading);
       const section = sections(after).find((item) => item.heading === change.heading);
       if (change.action === "add") {
         if (section || !change.text.startsWith(`${change.heading}
@@ -29937,6 +30607,8 @@ Remember: output only the JSON object described by the system prompt.`;
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -30741,6 +31413,8 @@ async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSig
       startedAt,
       status: params.status,
       messages: params.messages,
+      attemptedModel: args.model,
+      configuredModels: args.fallbackModels,
       error: params.error
     });
   };
@@ -31655,12 +32329,14 @@ function recordInvocation2(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "map-memories",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -32285,12 +32961,14 @@ function recordInvocation3(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "refresh-primers",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -33891,12 +34569,14 @@ function recordInvocation4(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: args.forceBroad ? "verify-broad" : "verify",
     startedAt,
     status: params.status,
     messages: params.messages,
+    attemptedModel: args.model,
+    configuredModels: args.fallbackModels,
     error: params.error
   });
 }
@@ -34772,6 +35452,25 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   let childSessionId = null;
   let hiddenHandle = null;
   let promptSettled = false;
+  let invocationRecorded = false;
+  const recordInvocation = (status, messages, error) => {
+    if (!parent || !childSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db,
+      parentSessionId: parent,
+      harness: deps.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
+      subagent: "dreamer",
+      task: config.task,
+      startedAt: helpers.invocationStartedAt,
+      status,
+      messages,
+      attemptedModel: config.model,
+      configuredModels: config.fallbackModels,
+      error
+    });
+  };
   try {
     if (deps.hiddenCompletionExecutor) {
       hiddenHandle = await deps.hiddenCompletionExecutor.open({
@@ -34856,18 +35555,8 @@ async function runRetrospectiveTask(config, ctx, helpers) {
       return { ...run, output };
     };
     const finish = (run, watermark) => {
-      if (parent && run) {
-        recordChildInvocation({
-          db,
-          parentSessionId: parent,
-          harness: "opencode",
-          subagent: "dreamer",
-          task: config.task,
-          startedAt: helpers.invocationStartedAt,
-          status: "completed",
-          messages: run.output
-        });
-      }
+      if (run)
+        recordInvocation("completed", run.output);
       return completedWindow(watermark);
     };
     const userLines = renderGateUserLines(messages);
@@ -34960,6 +35649,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
     log2(`[dreamer] retrospective: flagged=${flagged.length} learnings=${learnings.length} memory=${applied.memoryWritten} observations=${applied.observationsInserted} dropped=${applied.observationsDropped} rejected=${applied.rejected.length}`);
     return finish(deepenRun, scan.maxScannedTs);
   } catch (error) {
+    recordInvocation(abortController.signal.aborted ? "aborted" : failedInvocationStatus(error), undefined, error);
     if (!detectOverflow(error).isOverflow)
       throw error;
     const failures = (activeOverflow?.failures ?? 0) + 1;
@@ -35031,6 +35721,25 @@ async function runAgenticTask(config, ctx, helpers) {
   let childSessionId = null;
   let promptSettled = false;
   let expiredArchived = 0;
+  let invocationRecorded = false;
+  const recordInvocation = (status, messages, error) => {
+    if (!parent || !childSessionId || invocationRecorded)
+      return;
+    invocationRecorded = true;
+    recordChildInvocation({
+      db,
+      parentSessionId: parent,
+      harness: deps.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
+      subagent: "dreamer",
+      task,
+      startedAt: invocationStartedAt,
+      status,
+      messages,
+      attemptedModel: config.model,
+      configuredModels: config.fallbackModels,
+      error
+    });
+  };
   try {
     let curateMemories;
     let curateCategory;
@@ -35119,12 +35828,17 @@ async function runAgenticTask(config, ctx, helpers) {
           callContext: `dreamer:${task}`,
           metadata: { tokenBudget: config.tokenBudget, onBudgetUpdate },
           allowEmpty: task === "curate",
+          onOpened: (sessionId) => {
+            childSessionId = sessionId;
+          },
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: task === "curate" ? config.language ?? deps.language : undefined,
           timeoutMs: Math.min(Math.max(0, deadline - Date.now()), config.timeoutMinutes * 60 * 1000),
           signal: abortController.signal,
           parse: (text, completion) => {
+            if (task === "maintain-docs")
+              parseDocsProposalOutput(text);
             if (task !== "curate")
               return text;
             const memoryOperations = inspectCurateMemoryOperations(completion.messages);
@@ -35188,6 +35902,8 @@ async function runAgenticTask(config, ctx, helpers) {
             if (task !== "curate") {
               if (!text)
                 throw new Error("Dreamer returned no assistant output.");
+              if (task === "maintain-docs")
+                parseDocsProposalOutput(text);
               return text;
             }
             const memoryOperations = inspectCurateMemoryOperations(messages);
@@ -35234,21 +35950,10 @@ async function runAgenticTask(config, ctx, helpers) {
       helpers.reportProgress(curateRefused, curateRefused);
       log2(`[dreamer] curate safety summary: refused=${curateRefused}`);
     }
-    if (parent) {
-      recordChildInvocation({
-        db,
-        parentSessionId: parent,
-        harness: "opencode",
-        subagent: "dreamer",
-        task,
-        startedAt: invocationStartedAt,
-        status: "completed",
-        messages: run.output
-      });
-    }
+    recordInvocation("completed", run.output);
     if (task === "maintain-docs" && docsHashes && changes) {
       try {
-        if (run.validated === "[]") {
+        if (parseDocsProposalOutput(String(run.validated)).length === 0) {
           helpers.recordRun("completed", null, { progress: "no corrections proposed" });
           return {
             status: "completed",
@@ -35299,6 +36004,9 @@ async function runAgenticTask(config, ctx, helpers) {
         }
       } : {}
     };
+  } catch (error) {
+    recordInvocation(abortController.signal.aborted ? "aborted" : failedInvocationStatus(error), undefined, error);
+    throw error;
   } finally {
     heartbeat.stop();
     if (childSessionId)
@@ -36454,7 +37162,7 @@ function registerV2DreamScheduleTimer(args) {
       since_days: gitCommitIndexing.since_days,
       max_commits: gitCommitIndexing.max_commits
     } : undefined,
-    ensureRegistered: ensureProjectRegisteredFromOpenCodeDirectory
+    ensureRegistered: args.ensureRegistered ?? ensureProjectRegisteredFromOpenCodeDirectory
   }).catch((error) => {
     log2(`[magic-context] v2 dream timer registration failed (continuing without it): ${error}`);
     return;
@@ -36549,6 +37257,41 @@ function startDreamTrigger(context, args) {
   };
 }
 
+// src/v2/hooks/embedding-lifecycle.ts
+function createV2EmbeddingScope(initialProject) {
+  const releases = new Map;
+  const pending = new Set;
+  let disposed = false;
+  let disposal;
+  const claim = (project) => {
+    if (!releases.has(project))
+      releases.set(project, retainProjectEmbedding2(project));
+  };
+  if (initialProject)
+    claim(initialProject);
+  return {
+    ensureRegistered(directory, db) {
+      if (disposed)
+        return Promise.resolve();
+      const registration = ensureProjectRegisteredFromOpenCodeDirectory(directory, db, {
+        onRegistered: claim
+      });
+      pending.add(registration);
+      return registration.finally(() => pending.delete(registration));
+    },
+    dispose() {
+      disposed = true;
+      disposal ??= (async () => {
+        await Promise.allSettled([...pending]);
+        for (const release of releases.values())
+          release();
+        releases.clear();
+      })();
+      return disposal;
+    }
+  };
+}
+
 // src/v2/hooks/generate.ts
 function generateReplayAnchor(messages) {
   let index = messages.length - 1;
@@ -36561,26 +37304,70 @@ function generateReplayAnchor(messages) {
     return;
   return { id, tail: clonePreservingInstances(messages.slice(index + 1)) };
 }
+var DEFAULT_GENERATE_REPLAY_LIMITS = Object.freeze({
+  maxSessions: 16,
+  sessionMaxBytes: 128 * 1024 * 1024,
+  totalMaxBytes: 256 * 1024 * 1024
+});
 
 class V2GenerateReplay {
   prefixes = new Map;
+  totalBytes = 0;
+  limits;
+  constructor(limits = DEFAULT_GENERATE_REPLAY_LIMITS) {
+    if (!Number.isSafeInteger(limits.maxSessions) || limits.maxSessions < 1 || !Number.isSafeInteger(limits.sessionMaxBytes) || limits.sessionMaxBytes < 1 || !Number.isSafeInteger(limits.totalMaxBytes) || limits.totalMaxBytes < 1)
+      throw new Error("Generate replay limits must be positive integers");
+    this.limits = { ...limits };
+  }
   capture(draft, anchor) {
+    this.forget(draft.sessionID);
     if (!anchor) {
-      this.prefixes.delete(draft.sessionID);
       sessionLog2(draft.sessionID, "generate replay capture skipped: no-anchor");
       return;
     }
+    const parts = {
+      anchor: clonePreservingInstancesMeasured(anchor),
+      system: clonePreservingInstancesMeasured(draft.system),
+      messages: clonePreservingInstancesMeasured(draft.messages),
+      tools: clonePreservingInstancesMeasured(draft.tools)
+    };
+    const bytes = 256 + parts.anchor.bytes + parts.system.bytes + parts.messages.bytes + parts.tools.bytes;
+    if (bytes > this.limits.sessionMaxBytes || bytes > this.limits.totalMaxBytes) {
+      sessionLog2(draft.sessionID, `generate replay capture skipped: over-session-cap (${bytes} > ${Math.min(this.limits.sessionMaxBytes, this.limits.totalMaxBytes)} bytes)`);
+      return;
+    }
+    while (this.prefixes.size > 0 && (this.prefixes.size >= this.limits.maxSessions || this.totalBytes + bytes > this.limits.totalMaxBytes)) {
+      const oldest = this.prefixes.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.forget(oldest);
+    }
     this.prefixes.set(draft.sessionID, {
-      anchor: clonePreservingInstances(anchor),
+      anchor: parts.anchor.copy,
       model: `${draft.model.providerID}/${draft.model.id}`,
       agent: draft.agent,
-      system: clonePreservingInstances(draft.system),
-      messages: clonePreservingInstances(draft.messages),
-      tools: clonePreservingInstances(draft.tools)
+      system: parts.system.copy,
+      messages: parts.messages.copy,
+      tools: parts.tools.copy,
+      bytes
     });
+    this.totalBytes += bytes;
   }
   forget(sessionID) {
+    const prefix = this.prefixes.get(sessionID);
+    if (!prefix)
+      return;
     this.prefixes.delete(sessionID);
+    this.totalBytes -= prefix.bytes;
+  }
+  stats() {
+    return {
+      totalBytes: this.totalBytes,
+      sessions: [...this.prefixes].map(([sessionId, prefix]) => ({
+        sessionId,
+        bytes: prefix.bytes
+      }))
+    };
   }
   apply(draft) {
     const prefix = this.prefixes.get(draft.sessionID);
@@ -36590,6 +37377,8 @@ class V2GenerateReplay {
     };
     if (!prefix)
       return skip("no-prefix");
+    this.prefixes.delete(draft.sessionID);
+    this.prefixes.set(draft.sessionID, prefix);
     if (prefix.model !== `${draft.model.providerID}/${draft.model.id}`)
       return skip("model-mismatch");
     if (prefix.agent !== draft.agent)
@@ -36633,21 +37422,25 @@ function identity(slot) {
 
 class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
-  capture(sessionId, slot, input, served) {
+  capture(sessionId, slot, input, served, head) {
     this.systems.set(sessionId, {
       slot: identity(slot),
-      input: JSON.stringify(input),
-      served: structuredClone(served)
+      input: hostInputKey(input),
+      served: structuredClone(served),
+      head: head ? structuredClone(head) : null
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
-      return false;
+    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== hostInputKey(input))
+      return;
     target.splice(0, target.length, ...structuredClone(saved.served));
-    return true;
+    return { head: saved.head ? structuredClone(saved.head) : null };
   }
 }
+function hostInputKey(input) {
+  return JSON.stringify({ system: input.system, checkpoint: input.checkpoint });
+}
 
 // src/v2/hooks/model-limit-cache.ts
 var warmStarted = false;
@@ -37537,6 +38330,22 @@ function* readV2RawMessagePagesForConversion(openReader, sessionID, pageRows = C
 function createV2RawMessageReader(openReader) {
   const servedBoundaryCache = new Map;
   return {
+    getRevision: (sessionID) => {
+      const reader = openReader();
+      try {
+        return reader.latestSequence(sessionID);
+      } finally {
+        reader.close();
+      }
+    },
+    getCountAfterRevision: (sessionID, after, through) => {
+      const reader = openReader();
+      try {
+        return reader.messageCountAfterSequence(sessionID, after, through);
+      } finally {
+        reader.close();
+      }
+    },
     readPage: (sessionID, afterOrdinal, limit, finalWatermark, after) => {
       const reader = openReader();
       try {
@@ -51281,7 +52090,7 @@ function createCtxReduceTool(deps) {
       args = unwrapImitatedReducedArgs(args, ["drop"], { drop: "string" });
       const sessionId = toolContext.sessionID;
       if (!args.drop) {
-        return "Error: 'drop' must be provided.";
+        return `Error: 'drop' must be provided as a string of tag numbers, for example {"drop": "3-5,8"}.`;
       }
       const rustReduce = deps.rustToolBackends?.reduce;
       if (rustReduce) {
@@ -51547,6 +52356,7 @@ function createCtxSearchTool(deps) {
           return formatSearchResults2(query, idResults ?? [], toolContext.sessionID, diagnostics);
         }
       }
+      let rerankSkipped = "";
       const results = await unifiedSearch2(deps.db, toolContext.sessionID, projectPath, query, {
         limit: normalizeLimit2(args.limit),
         memoryEnabled,
@@ -51565,10 +52375,16 @@ function createCtxSearchTool(deps) {
         gitRepositoryAvailable: typeof toolContext.directory === "string" ? directoryHasGitMetadata(toolContext.directory) : undefined,
         explicitSearch: true,
         rerankConnectionFile: deps.rerankConnectionFile,
+        rerankConfig: deps.rerankConfig,
+        onRerankSkipped: (line) => {
+          rerankSkipped = line;
+        },
         searchMessageHistory: (request) => searchMessageHistoryOffThread(deps.db, request),
+        signal: toolContext.abort,
         ...dateRange
       });
-      return formatSearchResults2(query, results, toolContext.sessionID, diagnostics);
+      return formatSearchResults2(query, results, toolContext.sessionID, diagnostics) + (rerankSkipped ? `
+${rerankSkipped}` : "");
     }
   });
 }
@@ -51578,13 +52394,13 @@ function createCtxSearchTools(deps) {
   };
 }
 // src/v2/hooks/tools.ts
-async function registerTools(context, db, config, rustToolBackends, isInternalChild) {
+async function registerTools(context, db, config, rustToolBackends, isInternalChild, ensureProjectRegistered = ensureProjectRegisteredFromOpenCodeDirectory) {
   const compaction = isCompactionEnabled(config);
   setCtxReduceRegisteredGlobally(compaction);
   const project = {
     db,
     resolveProjectPath: (directory) => resolveProjectIdentityForSession(directory, config.allow_home_project),
-    ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
+    ensureProjectRegistered
   };
   const definitions = {
     ...compaction ? createCtxReduceTools({
@@ -51604,7 +52420,11 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
       smartNotesEnabled: config.smart_notes.enabled,
       ...rustToolBackends ? { rustToolBackends } : {}
     }),
-    ...createCtxSearchTools({ ...project, rerankConnectionFile: config.subc?.connection_file }),
+    ...createCtxSearchTools({
+      ...project,
+      rerankConnectionFile: config.subc?.connection_file,
+      rerankConfig: config.rerank
+    }),
     ...config.memory.enabled ? {
       ...createCtxMemoryTools({
         ...project,
@@ -51684,6 +52504,13 @@ function bindV2TransformDecision(args) {
 }
 
 // src/hooks/magic-context/auto-embed-session.ts
+function localPoolingPreflightPending(projectIdentity) {
+  const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
+  if (snapshot?.provider !== "local")
+    return false;
+  const metadata = getCachedLocalEmbeddingPooling(snapshot.model);
+  return !metadata || metadata.status === "unresolved";
+}
 function embeddingIdentity(projectIdentity) {
   const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
   return JSON.stringify([
@@ -51704,7 +52531,8 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
     invalidateAutoEmbedSession(sessionId);
     autoEmbedIdentityBySession.set(sessionId, identity);
   }
-  if (autoEmbedAttemptedBySession.has(sessionId) || embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0))
+  const poolingPreflightPending = localPoolingPreflightPending(deps.projectIdentity);
+  if (embedPauseBySession.has(sessionId) || embedRunStateBySession.has(sessionId) || Date.now() < (autoEmbedRetryAfterBySession.get(sessionId) ?? 0) || autoEmbedAttemptedBySession.has(sessionId) && !poolingPreflightPending)
     return;
   const controller = new AbortController;
   embedRunStateBySession.set(sessionId, controller);
@@ -51714,6 +52542,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
     let started = false;
     let reason = "error";
     let registeredIdentity = identity;
+    let poolingPendingAfterRegistration = poolingPreflightPending;
     try {
       await new Promise((resolve) => setTimeout(resolve, 0));
       if (controller.signal.aborted)
@@ -51721,6 +52550,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       await deps.ensureRegistered();
       if (controller.signal.aborted)
         return;
+      poolingPendingAfterRegistration = localPoolingPreflightPending(deps.projectIdentity);
       markActive();
       registeredIdentity = embeddingIdentity(deps.projectIdentity);
       autoEmbedIdentityBySession.set(sessionId, registeredIdentity);
@@ -51728,7 +52558,9 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       if (controller.signal.aborted || !coverage.enabled)
         return;
       if (coverage.embedded === coverage.total) {
-        complete = true;
+        complete = !poolingPendingAfterRegistration;
+        if (!complete)
+          retryDelay = 60000;
         return;
       }
       const model = getProjectEmbeddingSnapshot2(deps.projectIdentity)?.model;
@@ -51737,8 +52569,11 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
       const outcome = await embedSessionCompartmentChunks2(deps.db, deps.projectIdentity, sessionId, { signal: controller.signal, automatic: true });
       reason = outcome.status;
       const after = await getAutoEmbeddingSessionCoverage2(deps.db, deps.projectIdentity, sessionId);
-      complete = after.enabled && after.embedded === after.total;
-      if (!complete && outcome.status !== "busy" && outcome.status !== "aborted") {
+      complete = after.enabled && after.embedded === after.total && !poolingPendingAfterRegistration;
+      if (poolingPendingAfterRegistration) {
+        retryDelay = 60000;
+        reason = "pooling metadata unavailable";
+      } else if (!complete && outcome.status !== "busy" && outcome.status !== "aborted") {
         retryDelay = 60000;
         if (outcome.status === "nothing" || outcome.status === "done")
           reason = "deferred";
@@ -51763,7 +52598,7 @@ function maybeAutoEmbedSessionBackfill(deps, sessionId) {
 }
 
 // src/v2/hooks/transform-features.ts
-function createV2TransformFeatureDeps(config, compactionOff, directory) {
+function createV2TransformFeatureDeps(config, compactionOff, directory, ensureProjectRegistered = ensureProjectRegisteredFromOpenCodeDirectory) {
   return {
     protectedTools: config.protected_tools,
     commitClusterTrigger: config.commit_cluster_trigger,
@@ -51774,7 +52609,7 @@ function createV2TransformFeatureDeps(config, compactionOff, directory) {
       injectionBudgetTokens: config.memory.injection_budget_tokens,
       autoPromote: config.memory.auto_promote
     },
-    ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+    ensureProjectRegistered,
     historyBudgetPercentage: config.history_budget_percentage,
     experimentalUserMemories: userObservationCollectionEnabled2(config.dreamer),
     userObservationsRequested: userObservationsRequested2(config.dreamer),
@@ -51785,7 +52620,7 @@ function createV2TransformFeatureDeps(config, compactionOff, directory) {
       scoreThreshold: config.memory.auto_search?.score_threshold ?? 0.6,
       minPromptChars: config.memory.auto_search?.min_prompt_chars ?? 20,
       directory,
-      ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+      ensureProjectRegistered,
       wordRules: cavemanWordRulesForLanguage(config.language)
     },
     cavemanTextCompression: compactionOff ? undefined : config.caveman_text_compression?.enabled === true ? {
@@ -51795,7 +52630,7 @@ function createV2TransformFeatureDeps(config, compactionOff, directory) {
     } : undefined
   };
 }
-function createV2AutoEmbedSession(deps) {
+function createV2AutoEmbedSession(deps, ensureProjectRegistered = ensureProjectRegisteredFromOpenCodeDirectory) {
   return (sessionId) => {
     const directory = deps.resolveDirectory(sessionId);
     const projectIdentity = resolveProjectIdentityForSession(directory, deps.allowHomeProject);
@@ -51805,7 +52640,7 @@ function createV2AutoEmbedSession(deps) {
       db: deps.db,
       projectIdentity,
       ensureRegistered: async () => {
-        await ensureProjectRegisteredFromOpenCodeDirectory(directory, deps.db);
+        await ensureProjectRegistered(directory, deps.db);
         deps.onDirectoryResolved?.(sessionId, directory);
       }
     }, sessionId);
@@ -51894,6 +52729,26 @@ function persistV2UsageReading(args) {
 // src/v2/hooks/context.ts
 class V2LkgAdmissionReplay extends Error {
 }
+function applyCheckpointHead(draft, head) {
+  const { checkpoint, submitted } = head;
+  const first = draft.messages.find((message) => message.id === HEAD_IDS[0]);
+  const baseline = first?.content.find((part) => part.type === "text")?.text;
+  if (typeof baseline !== "string")
+    return false;
+  for (const part of checkpoint.content)
+    if (part.type === "text" && typeof part.text === "string") {
+      part.text = part.text.replace(`<summary>
+${submitted}
+</summary>`, `<summary>
+${baseline}
+</summary>`);
+    }
+  const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
+  if (volatile && first)
+    volatile.content.push(...first.content.filter((part) => part.type !== "text"));
+  draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== first));
+  return true;
+}
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
 var STORE_POOL_DISPOSE_WAIT_MS = 1000;
 function isBlockingV2TransformError(error) {
@@ -52119,6 +52974,7 @@ async function registerContext(context) {
     console.warn(`[magic-context] v2 setup disabled by conflicting context hooks: ${conflicts.reasons.join("; ")}`);
     return;
   }
+  const embeddings = createV2EmbeddingScope(resolveProjectIdentityForSession(directory, config.allow_home_project));
   const folds = new FoldOwner(context.storage);
   const nativeFoldMemory = !compactionOff && process.env.MC_OC2_INVISIBLE_FOLD === "1" ? nativeFoldCache(() => storage.require()) : undefined;
   const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader(), context.storage) : undefined;
@@ -52126,6 +52982,7 @@ async function registerContext(context) {
   const queriedModels = new Set;
   const rawLimits = new Map;
   const hiddenSessionErrors = new Map;
+  const hiddenModelActivity = new HiddenModelActivity;
   const liveModels = new Map;
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode2",
@@ -52174,7 +53031,7 @@ async function registerContext(context) {
   }) : undefined;
   const hiddenChildHook = new HiddenChildHook;
   await context.session.hook("http.request", (draft) => hiddenChildHook.cacheRequest(draft));
-  const tools = db && isDatabasePersisted(db) ? await registerTools(context, db, config, moduleToolBackends?.backends, (id) => hiddenChildHook.owns(id)) : undefined;
+  const tools = db && isDatabasePersisted(db) ? await registerTools(context, db, config, moduleToolBackends?.backends, (id) => hiddenChildHook.owns(id), embeddings.ensureRegistered) : undefined;
   const usage = new Map;
   const generateReplay = new V2GenerateReplay;
   await context.session.hook("http.response", async (draft) => {
@@ -52220,6 +53077,7 @@ async function registerContext(context) {
     await cleanupLegacyOnce(database);
     return createV2HiddenCompletionExecutor({
       ...context.session,
+      watchModelActivity: (sessionID, onOutput) => hiddenModelActivity.watch(sessionID, onOutput),
       get: async (input) => {
         const session = await context.session.get(input);
         const error = hiddenSessionErrors.get(input.sessionID);
@@ -52295,7 +53153,8 @@ async function registerContext(context) {
       liveConfig: () => liveConfigReader.poll().effective,
       executor: withLiveDreamerOutputCap(lateHiddenExecutor, config, () => liveConfigReader.poll().effective),
       openReader: openStoreReader,
-      rustModeModuleClient
+      rustModeModuleClient,
+      ensureRegistered: embeddings.ensureRegistered
     });
   };
   if (db && isDatabasePersisted(db))
@@ -52561,6 +53420,7 @@ async function registerContext(context) {
             break;
           const event = value;
           try {
+            hiddenModelActivity.observe(event);
             if (event.type === "provider.updated" || event.type === "model.updated") {
               queriedModels.clear();
               continue;
@@ -52568,6 +53428,10 @@ async function registerContext(context) {
             if (!event.data?.sessionID)
               continue;
             const sessionID = event.data.sessionID;
+            if (db && event.type === "session.revert.committed") {
+              const indexDb = db;
+              withoutSqliteTransformPass2(() => scheduleClearAndReindex(indexDb, sessionID, pagedRead));
+            }
             if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
               nativeFoldReplay?.onEvent(event);
               restoredRows.forget(sessionID);
@@ -52595,34 +53459,47 @@ async function registerContext(context) {
             if (event.type === "session.deleted") {
               clearLkgMeasuredRequest(sessionID);
               deletedSessions.add(sessionID);
-              transform?.clearSessionLogState(sessionID);
-              if (db) {
-                markSessionCleanupPending(db, sessionID);
-                clearSession(db, sessionID);
+              const failures = [];
+              try {
+                transform?.clearSessionLogState(sessionID);
+                if (db) {
+                  markSessionCleanupPending(db, sessionID);
+                  clearSession(db, sessionID, false, true);
+                }
+              } catch (error) {
+                failures.push(error);
               }
-              rawProviders.get(sessionID)?.();
-              rawProviders.delete(sessionID);
-              usage.delete(sessionID);
-              hiddenSessionErrors.delete(sessionID);
-              storageNoticeBySession.delete(sessionID);
-              liveModels.delete(sessionID);
-              variants.delete(sessionID);
-              agents.delete(sessionID);
-              channel1.delete(sessionID);
-              commitSeenLastPass.delete(sessionID);
-              clearEmbedSessionState(sessionID);
-              historyRefreshSessions.delete(sessionID);
-              clearPendingMaterialization(pendingMaterializationSessions, sessionID);
-              lastHeuristicsTurnId.delete(sessionID);
-              restoredRows.forget(sessionID);
-              if (nativeFoldReplay)
-                await nativeFoldReplay.forget(sessionID);
-              else
-                await forgetNativeFoldProvenance(context.storage, sessionID);
-              generateReplay.forget(sessionID);
-              systemPromptRefreshSessions.delete(sessionID);
-              systemPrompt?.clearSession(sessionID);
-              tagger.cleanup(sessionID);
+              try {
+                rawProviders.get(sessionID)?.();
+                rawProviders.delete(sessionID);
+                usage.delete(sessionID);
+                hiddenSessionErrors.delete(sessionID);
+                storageNoticeBySession.delete(sessionID);
+                liveModels.delete(sessionID);
+                variants.delete(sessionID);
+                agents.delete(sessionID);
+                channel1.delete(sessionID);
+                commitSeenLastPass.delete(sessionID);
+                clearEmbedSessionState(sessionID);
+                historyRefreshSessions.delete(sessionID);
+                clearPendingMaterialization(pendingMaterializationSessions, sessionID);
+                lastHeuristicsTurnId.delete(sessionID);
+                restoredRows.forget(sessionID);
+                if (nativeFoldReplay)
+                  await nativeFoldReplay.forget(sessionID);
+                else
+                  await forgetNativeFoldProvenance(context.storage, sessionID);
+                generateReplay.forget(sessionID);
+                systemPromptRefreshSessions.delete(sessionID);
+                systemPrompt?.clearSession(sessionID);
+                tagger.cleanup(sessionID);
+              } catch (error) {
+                failures.push(error);
+              }
+              if (failures.length === 1)
+                throw failures[0];
+              if (failures.length > 1)
+                throw new AggregateError(failures, "session deletion failed in both the store clear and the in-memory cleanup");
               continue;
             }
             if (event.type !== "session.execution.succeeded")
@@ -52670,7 +53547,7 @@ async function registerContext(context) {
     }) || draft.model.limit?.context || (state.lastObservedModelKey === modelKey ? state.lastUsageContextLimit : undefined);
     return materializeM0({
       ...createM0RenderOptions({
-        ...createV2TransformFeatureDeps(config, compactionOff, directory),
+        ...createV2TransformFeatureDeps(config, compactionOff, directory, embeddings.ensureRegistered),
         ...createV2ThresholdDeps(config)
       }, usage.get(draft.sessionID)?.usage ?? { percentage: 0, inputTokens: 0 }, modelKey, contextLimit, resolveProjectIdentityForSession(directory, config.allow_home_project)),
       db,
@@ -52740,6 +53617,42 @@ async function registerContext(context) {
       reader.close();
     }
   });
+  const temporalTimes = config.temporal_awareness === true;
+  const anchorTimesOnly = !temporalTimes && !rustModeModuleClient;
+  const timeIds = (messages) => {
+    if (temporalTimes)
+      return messages.flatMap((message) => message.id ? [message.id] : []);
+    if (!anchorTimesOnly)
+      return [];
+    const ids = [];
+    for (const message of [...messages].reverse()) {
+      if (message.id)
+        ids.push(message.id);
+      if (message.role === "assistant")
+        break;
+    }
+    return ids;
+  };
+  const restoreAfterCheckpoint = (args) => {
+    const { db, reader, draft, cut, boundaryRepair } = args;
+    const moduleBoundaryID = rustModeModuleClient ? getPersistedCompactionMarkerState(db, draft.sessionID)?.boundaryMessageId ?? null : null;
+    const moduleBoundarySeq = moduleBoundaryID ? reader.sequenceForId(draft.sessionID, moduleBoundaryID) : undefined;
+    const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
+    const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
+    const boundary = (nativeFoldReplay?.sourceChanged(draft.sessionID) && !rustModeModuleClient ? (reader.earliestSequence(draft.sessionID) ?? 0) - 1 : undefined) ?? (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
+    if (moduleBoundarySeq !== undefined)
+      sessionLog2(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
+    const present = new Set(args.messages.map((message) => message.id));
+    const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: (detail) => sessionLog2(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
+    } : undefined));
+    return [
+      ...rustModeModuleClient ? [] : coveredInstructionRows(reader, draft.sessionID, Math.min(boundary, cut.seq), draft.model),
+      ...restored,
+      ...args.messages.filter((message) => message !== args.incoming)
+    ];
+  };
   const runManagedContext = async (draft) => {
     rememberHostMedia(draft.messages);
     if (hiddenChildHook.apply(draft))
@@ -52751,12 +53664,18 @@ async function registerContext(context) {
       return;
     const systemAtEntry = structuredClone(draft.system);
     const slotAtEntry = getSlot(draft.sessionID);
+    let checkpointAtEntry;
+    let replayHead;
+    const hostInput = () => checkpointAtEntry === undefined ? undefined : { system: systemAtEntry, checkpoint: checkpointAtEntry };
     const restoreLkgSystem = () => {
       retirePendingSystemPromptDelivery(draft.sessionID);
-      if (!lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), systemAtEntry, draft.system)) {
+      const input = hostInput();
+      const restored = input && lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, draft.system);
+      if (!restored) {
         sessionLog2(draft.sessionID, "lkg_system_state_mismatch");
         throw new Error("LKG system identity is unavailable or changed");
       }
+      replayHead = restored.head;
     };
     const isMagicContextSynthetic = (id) => isAdmittedSynthetic(context, draft.sessionID, id);
     const newest = draft.messages.at(-1);
@@ -52765,6 +53684,24 @@ async function registerContext(context) {
       return;
     }
     await dropStorageNotices(draft.messages, isMagicContextSynthetic);
+    const hostMessagesAtEntry = [...draft.messages];
+    const passTimes = new Map;
+    const readTimes = (reader, messages) => {
+      const ids = timeIds(messages);
+      const missing = ids.filter((id) => !passTimes.has(id));
+      if (missing.length > 0) {
+        const read = reader.messageTimes(draft.sessionID, missing);
+        for (const id of missing)
+          passTimes.set(id, read.get(id) ?? null);
+      }
+      const times = new Map;
+      for (const id of ids) {
+        const time = passTimes.get(id);
+        if (time)
+          times.set(id, time);
+      }
+      return times;
+    };
     liveModels.set(draft.sessionID, {
       providerID: draft.model.providerID,
       modelID: draft.model.id
@@ -52776,8 +53713,9 @@ async function registerContext(context) {
     applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface, isSmartNoteSurfaceAvailable(config));
     const admissionDb = db ?? storage.current();
     const replayFits = (messages) => {
-      const system = structuredClone(draft.system);
-      if (!admissionDb || !draft.tools || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), draft.system, system))
+      const system = [];
+      const input = hostInput();
+      if (!admissionDb || !draft.tools || !input || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, system))
         return false;
       const limit = lkgReplayLimit({
         db: admissionDb,
@@ -52812,14 +53750,75 @@ async function registerContext(context) {
         })
       }).fit === "under";
     };
+    const buildReplayInput = async () => {
+      let messages = [...hostMessagesAtEntry];
+      const admitted = new Set;
+      let times;
+      try {
+        const reader = openStoreReader();
+        try {
+          const cut = reader.latestCompaction(draft.sessionID);
+          const localCut = cut && isLocalCheckpoint(cut) ? cut : undefined;
+          const incoming = localCut && messages.find((message) => message.id === localCut.id);
+          if (localCut && !incoming || cut && nativeFoldReplay)
+            return;
+          checkpointAtEntry = incoming || null;
+          const modeDb = db ?? storage.current();
+          const subagent = modeDb ? storedSubagentMode(modeDb, draft.sessionID) : undefined;
+          if (subagent === undefined)
+            return;
+          if (subagent)
+            removePrimaryOnlyTools(draft.tools);
+          if (!rustModeModuleClient) {
+            const candidates = syntheticCandidates(context, draft.sessionID, reader.syntheticMessageIDs(draft.sessionID));
+            for (const message of messages)
+              if (message.id && candidates.has(message.id) && await isAdmittedSynthetic(context, draft.sessionID, message.id))
+                admitted.add(message.id);
+            const replayDb = db ?? storage.current();
+            if (localCut && incoming && replayDb)
+              messages = restoreAfterCheckpoint({
+                db: replayDb,
+                reader,
+                draft,
+                messages,
+                cut: localCut,
+                incoming,
+                boundaryRepair: undefined
+              });
+            else if (localCut)
+              return;
+            times = readTimes(reader, messages);
+          }
+        } finally {
+          reader.close();
+        }
+      } catch (error) {
+        sessionLog2(draft.sessionID, "lkg replay input unavailable", error);
+        return;
+      }
+      const replayDraft = { ...draft, messages };
+      return {
+        draft: replayDraft,
+        mapped: adaptPayload(replayDraft, admitted, times, anchorTimesOnly)
+      };
+    };
+    const adoptReplay = (replayed) => {
+      if (replayed !== draft)
+        draft.messages.splice(0, draft.messages.length, ...replayed.messages);
+      if (replayHead)
+        applyCheckpointHead(draft, replayHead);
+    };
     let postFold = false;
     try {
       if (!compactionOff && admissionDb)
         await withAsyncPrivilegedWriter2(admissionDb, () => {
           return;
         }, {
-          beforeRetry: (error) => {
-            const mapped = adaptPayload(draft);
+          beforeRetry: async (error) => {
+            const input = await buildReplayInput();
+            if (!input)
+              return;
+            const { mapped } = input;
             if (tryMessagesTransformLkgReplay({
               output: mapped,
               sessionId: draft.sessionID,
@@ -52830,6 +53829,7 @@ async function registerContext(context) {
               onLkgReplay: restoreLkgSystem
             })) {
               mapped.commit();
+              adoptReplay(input.draft);
               throw new V2LkgAdmissionReplay;
             }
           }
@@ -52919,7 +53919,7 @@ async function registerContext(context) {
       await cacheV2SessionDirectory(context.session, draft.sessionID, sessionDirectories);
       prepareHistorySession(draft.sessionID);
       transform ??= createTransform({
-        ...createV2TransformFeatureDeps(config, compactionOff, directory),
+        ...createV2TransformFeatureDeps(config, compactionOff, directory, embeddings.ensureRegistered),
         cacheTtlConfig: config.cache_ttl,
         cacheTtlConfigured: config.cacheTtlConfigured,
         sampleCacheTtlConfig: () => liveConfigReader.poll().effective,
@@ -52929,7 +53929,7 @@ async function registerContext(context) {
         contextUsageMap: usage,
         compactionOff,
         storeGeneration: "v2",
-        normalizeRestoredAssistantText: stripCopiedTagNotation,
+        normalizeRestoredAssistantText: (text, providerID) => stripCopiedTagNotation(text, providerID === "anthropic"),
         refreshSourceContents: (sessionID) => nativeFoldReplay?.needsHeadRebuild(sessionID) ?? false,
         hostCleanupCompactionMarkers: () => ({
           verified: true,
@@ -52966,7 +53966,7 @@ async function registerContext(context) {
           resolveDirectory: (sessionID) => sessionDirectories.get(sessionID) ?? directory,
           allowHomeProject: config.allow_home_project,
           recompProgressBySession: new Map
-        }),
+        }, embeddings.ensureRegistered),
         hiddenCompletionExecutor,
         historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
         historianModel: historianModels.primary,
@@ -53024,6 +54024,7 @@ async function registerContext(context) {
         postFold = cut !== undefined;
         if (localCut && !incoming)
           throw new Error("The host checkpoint disappeared from the context draft");
+        checkpointAtEntry = incoming || null;
         let nativeRestored;
         if (cut && nativeFoldReplay && await nativeFoldReplay.admits(draft.sessionID, cut, reader)) {
           try {
@@ -53065,22 +54066,17 @@ async function registerContext(context) {
             checkpoint = structuredClone(identity.rendered ?? incoming);
             submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
           }
-          const moduleBoundaryID = rustModeModuleClient ? getPersistedCompactionMarkerState(db, draft.sessionID)?.boundaryMessageId ?? null : null;
-          const moduleBoundarySeq = moduleBoundaryID ? reader.sequenceForId(draft.sessionID, moduleBoundaryID) : undefined;
-          const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
-          const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
-          const boundary = (nativeFoldReplay?.sourceChanged(draft.sessionID) && !rustModeModuleClient ? (reader.earliestSequence(draft.sessionID) ?? 0) - 1 : undefined) ?? (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
-          if (moduleBoundarySeq !== undefined)
-            sessionLog2(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
-          const present = new Set(draft.messages.map((message) => message.id));
-          const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
-            asset: hostMediaAsset,
-            unavailable: (detail) => sessionLog2(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
-          } : undefined));
-          draft.messages.splice(0, draft.messages.length, ...rustModeModuleClient ? [] : coveredInstructionRows(reader, draft.sessionID, Math.min(boundary, cut.seq), draft.model), ...restored, ...draft.messages.filter((message) => message !== incoming));
-        }
-        if (config.temporal_awareness === true)
-          messageTimes = reader.messageTimes(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
+          draft.messages.splice(0, draft.messages.length, ...restoreAfterCheckpoint({
+            db,
+            reader,
+            draft,
+            messages: draft.messages,
+            cut: localCut,
+            incoming,
+            boundaryRepair
+          }));
+        }
+        messageTimes = readTimes(reader, draft.messages);
       } finally {
         reader.close();
       }
@@ -53097,7 +54093,7 @@ async function registerContext(context) {
           nativeFoldReplay.invalidate(draft.sessionID, true);
         }
       }
-      const mapped = adaptPayload(draft, admitted, messageTimes);
+      const mapped = adaptPayload(draft, admitted, messageTimes, anchorTimesOnly);
       bindSystemDateRequestIdentity(mapped, draft);
       await createMessagesTransformHandler({
         magicContext: { "experimental.chat.messages.transform": transform },
@@ -53114,24 +54110,9 @@ async function registerContext(context) {
       if (db) {
         await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
       }
-      if (checkpoint && submitted !== undefined) {
-        const head = draft.messages.find((message) => message.id === HEAD_IDS[0]);
-        const baseline = head?.content.find((part) => part.type === "text")?.text;
-        if (typeof baseline === "string") {
-          for (const part of checkpoint.content)
-            if (part.type === "text" && typeof part.text === "string") {
-              part.text = part.text.replace(`<summary>
-${submitted}
-</summary>`, `<summary>
-${baseline}
-</summary>`);
-            }
-          const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
-          if (volatile && head)
-            volatile.content.push(...head.content.filter((part) => part.type !== "text"));
-          draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
-        }
-      }
+      const head = replayHead !== undefined ? replayHead : checkpoint && submitted !== undefined ? { checkpoint, submitted } : null;
+      const servedHead = head && structuredClone(head);
+      const headApplied = head ? applyCheckpointHead(draft, head) : false;
       if (nativeMessages && !checkpoint) {
         try {
           await nativeFoldReplay?.capture(draft, nativeMessages);
@@ -53142,7 +54123,7 @@ ${baseline}
       }
       const capturedSlot = getSlot(draft.sessionID);
       if (capturedSlot && (!slotAtEntry || capturedSlot.capturedAt !== slotAtEntry.capturedAt || capturedSlot.captureSequence !== slotAtEntry.captureSequence || capturedSlot.jsonPrefix !== slotAtEntry.jsonPrefix)) {
-        lkgSystems.capture(draft.sessionID, capturedSlot, systemAtEntry, draft.system);
+        lkgSystems.capture(draft.sessionID, capturedSlot, { system: systemAtEntry, checkpoint: checkpointAtEntry ?? null }, draft.system, headApplied ? servedHead : null);
       }
     } catch (error) {
       if (error instanceof V2LkgAdmissionReplay)
@@ -53151,8 +54132,11 @@ ${baseline}
         throw error;
       if (!compactionOff && (isTransientSqliteError2(error) || error instanceof StorageBusyRefusalError)) {
         if (isTransientSqliteError2(error)) {
-          const mapped = adaptPayload(draft);
+          const input = await buildReplayInput();
           try {
+            if (!input)
+              throw new StorageBusyRefusalError(error, "v2-context");
+            const { mapped } = input;
             await createMessagesTransformHandler({
               replayFits,
               onLkgReplay: restoreLkgSystem,
@@ -53164,6 +54148,7 @@ ${baseline}
               }
             })({}, mapped);
             mapped.commit();
+            adoptReplay(input.draft);
             return;
           } catch (replayError) {
             if (!(replayError instanceof StorageBusyRefusalError))
@@ -53245,7 +54230,8 @@ ${baseline}
         return null;
       }
     },
-    storageDir
+    storageDir,
+    getDebugMemoryHolders: () => ({ generateReplay: generateReplay.stats() })
   });
   rpcServer.handle("dream", async (params) => {
     const sessionId = String(params.sessionId ?? "");
@@ -53330,6 +54316,7 @@ ${baseline}
       deletedSessions.clear();
       await dreamTrigger?.dispose();
       await maintenanceTimer?.dispose();
+      await embeddings.dispose();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();