@retaw106/mmc-oc 2.3.0 → 2.5.0

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

@@ -34,6 +34,19 @@ import {
   resolveProjectIdentityForSession,
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity,
+  parseProviderModel,
+  modelBodyField,
+  toModelEntry,
+  HiddenCompletionRefusal,
+  HIDDEN_HISTORIAN_AGENT,
+  resolveHistorianStepCap,
+  HIDDEN_RUN_DISPOSED_REASON,
+  noteChildOfDisposedInstance,
+  hiddenChildPermissions,
+  registerHiddenChildAgents,
+  HiddenAgentStepLimit,
+  HiddenChildHook,
+  isNonRetryable,
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY,
   computeNormalizedHash,
@@ -58,7 +71,6 @@ import {
   searchMemoriesFTSUnion,
   clearMemoryVerifications,
   queueMemoryMutation,
-  scheduleAfterBootQuiet,
   BoundedSessionMap,
   registerOwnRpcServerInstance,
   rpcPortDir,
@@ -68,6 +80,12 @@ import {
   dirtyLkgRecoveryRevision,
   ownsLkgDirtyFence,
   invalidateCleanLkgRecoveryFence,
+  cleanSearchText,
+  keywordRelevance,
+  matchedSearchSnippet,
+  gaDatabasePath,
+  RAW_MESSAGE_TYPES,
+  V2StoreReaderPool,
   getLastIndexedOrdinal,
   getIndexedMessageIdAtOrdinal,
   getIndexedMessageCorpusSize,
@@ -75,6 +93,8 @@ import {
   isMessageIndexReconciledThrough,
   clearIndexedMessages,
   indexMessagesAfterOrdinal,
+  sweepOrphanedOpenCodeMessageIndexesCooperatively,
+  scheduleAfterBootQuiet,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -82,6 +102,7 @@ import {
   getMaxM0MutationId,
   ensureSessionMetaRow,
   clearCachedM0M1,
+  clearCachedM0,
   getCompartments,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
@@ -97,6 +118,7 @@ import {
   HYGIENE_PROVIDER_UNITS_VERSION,
   sessionDecisionCalibration,
   transitionSessionHygieneUnits,
+  readEpochFloorSnapshot,
   getProtectionWindowForSession,
   ReplayDocumentError,
   readReplayEnvelope,
@@ -173,9 +195,6 @@ import {
   getUnpublishedAutoSearchNoHint,
   forgetUnpublishedAutoSearchNoHint,
   registerAutoSearchWork,
-  gaDatabasePath,
-  RAW_MESSAGE_TYPES,
-  V2StoreReaderPool,
   getOrCreateSessionMeta,
   updateSessionMeta,
   advanceToolReclaimWatermark,
@@ -183,6 +202,7 @@ import {
   clearSession,
   requestPendingMaterialization,
   pendingMaterializationOrigin,
+  hasPendingMaterializationOrigin,
   clearPendingMaterialization,
   recordSystemPromptForRequest,
   recordHeldHeadForRequest,
@@ -242,18 +262,10 @@ import {
   sourceNameForMemory,
   rebaseSessionCoordinatesAsync,
   renderUserFacingFailure,
+  userFacingFailureCode,
   renderCapabilityRefusal,
-  HiddenCompletionRefusal,
-  HIDDEN_HISTORIAN_AGENT,
-  resolveHistorianStepCap,
-  hiddenChildPermissions,
-  registerHiddenChildAgents,
-  HiddenAgentStepLimit,
-  HiddenChildHook,
-  parseProviderModel,
-  toModelEntry,
   ACTIVE_TOOL_IDS,
-  promptSurfaceHashMaterial,
+  systemPromptFingerprint,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
   getOpenCodeDbPath,
@@ -285,6 +297,7 @@ import {
   prepareCachedM0M1Replay,
   hasCompleteCachedM0M1,
   injectM0M1,
+  omitIncompleteFileTokenTotals,
   RECOVERY_NO_HEAD_LIMIT,
   deriveProtectedTailTokenTarget,
   selectPerRunCap,
@@ -294,7 +307,7 @@ import {
   recordHighPressureNoEligibleHead,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-kw21z5pe.js";
+} from "./index-0d40b4q8.js";
 import {
   getHarness,
   getDataDir,
@@ -326,6 +339,16 @@ import {
 import {
   normalizeProtectedToolName,
   mergeProtectedTools,
+  detectLatestTurnThinkingMismatch,
+  isPrefixBoundThinkingModel,
+  detectOverflow,
+  stripWellFormedLeadingTagPrefix,
+  stripPersistedAssistantText,
+  byteSize,
+  stripTagPrefix,
+  peelLeadingMcTagNotation,
+  prependTag,
+  isThinkingPart,
   isRecord,
   protectedToolTagNumbers,
   protectedToolTokenCount,
@@ -335,13 +358,7 @@ import {
   preloadTokenizer,
   estimateTokens,
   estimateFixedPromptTokens,
-  stripWellFormedLeadingTagPrefix,
-  stripPersistedAssistantText,
-  byteSize,
-  stripTagPrefix,
-  peelLeadingMcTagNotation,
-  prependTag,
-  isThinkingPart,
+  currentReclaimableToolOutputCount,
   contentTagOwnerMessageId,
   estimateImageTokensFromDataUrl,
   estimateToolAttachmentImageTokens,
@@ -374,6 +391,7 @@ import {
   getPendingOpsCount,
   clearPendingOps,
   removePendingOp,
+  tagRevisionKey,
   tagIdentityRevisionKey,
   getRecentTagOwnerMessageIds,
   AGE_RECLAIM_MIN_TOKENS,
@@ -390,6 +408,7 @@ import {
   backfillTagTokenCounts,
   insertTag,
   updateTagStatus,
+  markTagDropped,
   markWhitespaceAssistantTagInert,
   getInertWhitespaceAssistantTags,
   getInertWhitespaceAssistantTagsByNumbers,
@@ -416,12 +435,16 @@ import {
   pickNearestPriorOwner,
   expandToolPart,
   markHostUnservedRow,
+  isHostRenderedSystemMessage,
+  markCoveredInstructionRow,
+  isCoveredInstructionRow,
+  takeCoveredInstructionRows,
+  cloneKeepingCoveredInstructionMarks,
   estimateTrueRawMessageTokens,
   stripSystemInjection,
   isTextPart,
   isToolPartWithOutput,
   isFilePart,
-  buildFileSourceContent,
   toolPartHasUserAnswer,
   recordToolParameters,
   createDroppedInputGuard,
@@ -431,13 +454,11 @@ import {
   recordToolDefinition,
   getMeasuredToolDefinitionTokens,
   describeFinalWireTail,
+  estimatePartImageTokens,
   estimateMessageTokens,
   wireContentBytes,
   createFinalWireUsageTracker,
   estimateFinalWireInputTokens,
-  detectLatestTurnThinkingMismatch,
-  isPrefixBoundThinkingModel,
-  detectOverflow,
   modelAcceptsEmptyContent,
   isAnthropicFamilyRoute,
   neutralizeDroppedReasoningPart,
@@ -463,10 +484,16 @@ import {
   primeTailRawMessageCache2,
   primeInMemoryTailRawMessageCache2,
   readRawSessionMessageIdOrdinalsForRange2,
+  hasRawSessionMessageById2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-z2w1eq3y.js";
+} from "./index-1vxffj5j.js";
+import {
+  normalizeModelEntry2,
+  resolveHistorianModel2
+} from "./index-azbmnekv.js";
 import {
+  Database,
   getSqliteMemoryStats,
   withSqliteBackgroundWriter,
   withSqliteTransformPass,
@@ -476,7 +503,7 @@ import {
   withAsyncPrivilegedWriter,
   indexCoordinationInput,
   withIndexChunk
-} from "./index-czba8tw3.js";
+} from "./index-pte3cfs9.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -493,7 +520,7 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-18yrysyj.js";
+} from "./index-bpjjcdy9.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -506,14 +533,14 @@ import {
   getErrorMessage,
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./index-a5mw0xp3.js";
-import {
-  resolveHistorianModel2
-} from "./index-z2g20msd.js";
+} from "./index-k25thxq7.js";
 import {
   logSlowWriteTransaction
 } from "./index-yjv8dpht.js";
 
+// src/v2/hooks/context.ts
+import { setTimeout as delay } from "node:timers/promises";
+
 // src/config/index.ts
 import { existsSync as existsSync4 } from "node:fs";
 
@@ -3159,6 +3186,40 @@ function currentPluginConfigReader(directory) {
   return pluginReaders.get(directory);
 }
 
+// src/features/magic-context/memory-maintainer/model-chain.ts
+var MAINTENANCE_MODEL_UNCONFIGURED_MESSAGE = "memory maintenance has no primary model configured — set maintenance.model or historian.model in the user-level mmc config (fallback_models alone does not enable maintenance; the session model is never inherited)";
+function inheritMaintenanceModelConfig(config) {
+  const { maintenance, historian } = config;
+  if (maintenance.model !== undefined || historian?.model === undefined)
+    return maintenance;
+  const entry = typeof historian.model === "string" ? { model: historian.model } : historian.model;
+  return {
+    ...maintenance,
+    model: {
+      ...entry,
+      variant: entry.variant ?? historian.variant,
+      thinking_level: entry.thinking_level ?? historian.thinking_level
+    },
+    fallback_models: maintenance.fallback_models ?? historian.fallback_models
+  };
+}
+function resolveMaintenanceModelChain(config, harness) {
+  const primary = normalizeModelEntry2(config.model, harness);
+  if (!primary)
+    return;
+  const fallbacks = [];
+  for (const entry of config.fallback_models ?? []) {
+    const resolved = normalizeModelEntry2(entry, harness);
+    if (resolved)
+      fallbacks.push(resolved);
+  }
+  return { primary, fallbacks };
+}
+function hasMaintenancePrimary(config) {
+  const primary = toModelEntry(config.model);
+  return primary !== undefined && primary.model.trim().length > 0;
+}
+
 // src/features/magic-context/memory-maintainer/dream-state.ts
 var getDreamStateStatements = new WeakMap;
 var setDreamStateStatements = new WeakMap;
@@ -4500,6 +4561,7 @@ async function executeGuardedRun(opts, holderId, leaseKey, acquisition) {
       pending,
       fullPool: roundState.snapshot,
       shouldContinue: () => meter.shouldContinue(),
+      remainingWallMs: () => Math.max(0, config.budgets.wallMs - meter.getState().spent.wallMs),
       recordUsage: (delta) => meter.recordUsage(delta),
       recordToolStep: () => meter.recordToolStep(),
       refuseToolStep: () => meter.refuseToolStep()
@@ -4798,49 +4860,86 @@ function transcriptFromCompletion(completion, createdAt) {
     }
   ];
 }
-async function runOc2MaintenancePhase(ctx, phase, deps, stageAManifest = "") {
-  if (!deps.executor)
-    return emptyPhaseResult();
-  const agentId = phase === "A" ? MEMORY_MAINTAINER_A_AGENT : MEMORY_MAINTAINER_B_AGENT;
-  const system = phase === "A" ? MEMORY_MAINTAINER_A_SYSTEM_PROMPT : MEMORY_MAINTAINER_B_SYSTEM_PROMPT;
-  const basePrompt = buildPhasePrompt(ctx, phase, deps, stageAManifest);
-  let manifestText = "";
-  let messages;
-  for (let round = 0;round < 2; round += 1) {
-    const decision = ctx.shouldContinue();
-    if (decision === "stop")
-      break;
-    const prompt = decision === "finalize" ? `${MEMORY_MAINTAINER_FINALIZE_INSTRUCTION}
-
-${basePrompt}` : basePrompt;
+async function attemptPhaseModelChain(ctx, phase, executor, deps, agentId, system, prompt) {
+  const chain = [deps.modelChain.primary, ...deps.modelChain.fallbacks];
+  let lastError;
+  for (let index = 0;index < chain.length; index += 1) {
+    const entry = toModelEntry(chain[index]);
+    if (!entry || entry.model.trim().length === 0)
+      continue;
+    if (!parseProviderModel(entry.model)) {
+      if (index === 0) {
+        throw new Error(`memory maintenance: primary model "${entry.model}" is not in provider/model form — the hidden executor cannot use it and no model substitution is allowed`);
+      }
+      log(`[magic-context][maintenance] phase ${phase}: dropping invalid fallback spec: ${entry.model}`);
+      continue;
+    }
+    if (index > 0) {
+      if (ctx.shouldContinue() !== "continue")
+        throw lastError;
+      log(`[magic-context][maintenance] phase ${phase}: switching to fallback model ${entry.model} (attempt ${index + 1}/${chain.length})`);
+    }
     const identity = {
       parentSessionId: deps.parentSessionId(),
       kind: "memory-maintenance",
       agent: agentId,
       system,
-      timeoutMs: deps.budget.wallMs,
+      model: entry,
+      timeoutMs: Math.max(1000, Math.min(deps.budget.wallMs, ctx.remainingWallMs())),
       title: `magic-context-maintainer-${phase.toLowerCase()}`,
       directory: deps.directory() ?? ""
     };
-    const handle = await deps.executor.open(identity);
-    let completion;
+    const handle = await executor.open(identity);
     let promptSettled = false;
     try {
       const request = {
         path: { id: handle.id },
-        body: { parts: [{ type: "text", text: prompt }] }
+        body: {
+          parts: [{ type: "text", text: prompt }],
+          ...modelBodyField(entry)
+        }
       };
-      await deps.executor.attempt(handle, request);
-      completion = await deps.executor.collect(handle, 50);
+      try {
+        await executor.attempt(handle, request);
+      } catch (error) {
+        lastError = error;
+        if (index >= chain.length - 1 || isNonRetryable(error))
+          throw error;
+        log(`[magic-context][maintenance] phase ${phase}: model ${entry.model} failed: ${error instanceof Error ? error.message : String(error)}; trying next fallback`);
+        continue;
+      }
+      const completion = await executor.collect(handle, 50);
       promptSettled = true;
+      return completion;
     } finally {
-      await deps.executor.close(handle, {
+      await executor.close(handle, {
         promptSettled,
         privacySensitive: false,
         context: "memory-maintenance",
         log: (message) => log(`[magic-context][maintenance] ${message}`)
       });
     }
+  }
+  if (lastError !== undefined)
+    throw lastError;
+  return;
+}
+async function runOc2MaintenancePhase(ctx, phase, deps, stageAManifest = "") {
+  if (!deps.executor)
+    return emptyPhaseResult();
+  const agentId = phase === "A" ? MEMORY_MAINTAINER_A_AGENT : MEMORY_MAINTAINER_B_AGENT;
+  const system = phase === "A" ? MEMORY_MAINTAINER_A_SYSTEM_PROMPT : MEMORY_MAINTAINER_B_SYSTEM_PROMPT;
+  const basePrompt = buildPhasePrompt(ctx, phase, deps, stageAManifest);
+  let manifestText = "";
+  let messages;
+  for (let round = 0;round < 2; round += 1) {
+    const decision = ctx.shouldContinue();
+    if (decision === "stop")
+      break;
+    const prompt = decision === "finalize" ? `${MEMORY_MAINTAINER_FINALIZE_INSTRUCTION}
+
+${basePrompt}` : basePrompt;
+    const completion = await attemptPhaseModelChain(ctx, phase, deps.executor, deps, agentId, system, prompt);
     if (completion) {
       const inputTotal = completion.usage.input + completion.usage.cacheRead + completion.usage.cacheWrite;
       ctx.recordUsage({ inputTokens: inputTotal, outputTokens: completion.usage.output });
@@ -4898,9 +4997,18 @@ function createOc2MaintenanceRunFactory(options) {
       if (!options.executor) {
         throw new Error("memory maintenance: no hidden completion executor wired");
       }
+      const chain = resolveMaintenanceModelChain(options.config(), "opencode");
+      if (!chain) {
+        throw new Error(MAINTENANCE_MODEL_UNCONFIGURED_MESSAGE);
+      }
+      const primarySpec = toModelEntry(chain.primary)?.model ?? "";
+      if (!parseProviderModel(primarySpec)) {
+        throw new Error(`memory maintenance: primary model "${primarySpec}" is not in provider/model form — the hidden executor cannot use it and no model substitution is allowed`);
+      }
       const cfg = options.config();
       const phaseDeps = {
         executor: options.executor,
+        modelChain: chain,
         budget: cfg.budgets,
         parentSessionId: () => signals.parentSessionId,
         directory: () => signals.directory,
@@ -4947,6 +5055,8 @@ var RECONCILIATION_BATCH_SIZE = 100;
 
 class MagicContextMessageIndexHeapHolder {
   reconciledSessions = new Set;
+  reconciledSnapshots = new Map;
+  stalledSessions = new Set;
   reconciliationScheduledSessions = new Set;
   clearAndReindexScheduledSessions = new Map;
   sessionLocks = new Map;
@@ -5029,23 +5139,32 @@ function detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMess
     return null;
   return `indexed id '${indexedId}' at ordinal ${cursor} but projection has '${projectedId}'`;
 }
+function logReconciliationStall(sessionId, reason) {
+  if (heapHolder.stalledSessions.has(sessionId))
+    return;
+  heapHolder.stalledSessions.add(sessionId);
+  sessionLog(sessionId, `message FTS reconciliation stalled: ${reason}; will retry`);
+}
 async function reconcileSessionIndex(db, sessionId, readMessages) {
   if (!await sourceReady(readMessages, sessionId))
     return false;
   await runWithSessionLock(sessionId, async () => {
-    if (heapHolder.reconciledSessions.has(sessionId))
+    if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId))
       return;
     let fallbackSnapshot = null;
     try {
       const fullReader = typeof readMessages === "function" ? readMessages : null;
-      const finalWatermark = readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
+      const revision = readMessages.getRevision?.(sessionId);
+      const previous = heapHolder.reconciledSnapshots.get(sessionId);
+      const finalWatermark = previous && revision === previous.revision ? previous.count : revision !== undefined && readMessages.getCountAfterRevision ? previous && revision > previous.revision ? previous.count + readMessages.getCountAfterRevision(sessionId, previous.revision, revision) : readMessages.getCountAfterRevision(sessionId, -1, revision) : readMessages.getCount ? readMessages.getCount(sessionId) : (fallbackSnapshot = fullReader?.(sessionId) ?? []).length;
       let cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
-      let after;
-      const misalignment = detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMessages, fallbackSnapshot);
+      let after = cursor === previous?.count ? previous.after : undefined;
+      const misalignment = revision !== undefined && previous && revision >= previous.revision ? null : detectIndexMisalignment(db, sessionId, cursor, finalWatermark, readMessages, fallbackSnapshot);
       if (misalignment !== null) {
         sessionLog(sessionId, `message FTS index misaligned (${misalignment}); clearing for full re-index`);
         withSqliteBackgroundWriter(() => clearIndexedMessages(db, sessionId));
         cursor = getMessageIndexReconciliationStartOrdinal(db, sessionId);
+        after = undefined;
       }
       while (cursor < finalWatermark) {
         const pageEnd = Math.min(finalWatermark, cursor + RECONCILIATION_BATCH_SIZE);
@@ -5065,6 +5184,22 @@ async function reconcileSessionIndex(db, sessionId, readMessages) {
       }
       if (isMessageIndexReconciledThrough(db, sessionId, finalWatermark)) {
         heapHolder.reconciledSessions.add(sessionId);
+        heapHolder.stalledSessions.delete(sessionId);
+        if (revision !== undefined) {
+          if (!after && finalWatermark > 0 && readMessages.readPage) {
+            const last = readMessages.readPage(sessionId, finalWatermark - 1, 1, finalWatermark).at(-1);
+            if (last?.ordinal === finalWatermark && typeof last.createdAt === "number")
+              after = { timeCreated: last.createdAt, id: last.id };
+          }
+          heapHolder.reconciledSnapshots.set(sessionId, {
+            revision,
+            count: finalWatermark,
+            after
+          });
+        }
+      } else {
+        heapHolder.reconciledSessions.delete(sessionId);
+        logReconciliationStall(sessionId, `gap after ordinal ${cursor} (store count ${finalWatermark})`);
       }
     } finally {
       heapHolder.activeReconcilerBuffers.delete(sessionId);
@@ -5073,30 +5208,42 @@ async function reconcileSessionIndex(db, sessionId, readMessages) {
   return true;
 }
 function scheduleReconciliation(db, sessionId, readMessages) {
-  if (heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
+  if (!readMessages.getRevision && heapHolder.reconciledSessions.has(sessionId) || heapHolder.reconciliationScheduledSessions.has(sessionId)) {
     return;
   }
   heapHolder.reconciliationScheduledSessions.add(sessionId);
   scheduleAfterBootQuiet(() => {
     defer(() => {
+      let appendedDuringReconciliation = false;
+      const previousSnapshot = heapHolder.reconciledSnapshots.get(sessionId);
       reconcileSessionIndex(db, sessionId, readMessages).then((ran) => {
-        if (ran)
+        if (ran) {
+          const snapshot = heapHolder.reconciledSnapshots.get(sessionId);
+          appendedDuringReconciliation = snapshot !== undefined && snapshot !== previousSnapshot && readMessages.getRevision !== undefined && readMessages.getRevision(sessionId) !== snapshot.revision;
           return;
+        }
         setTimeout(() => {
           heapHolder.reconciliationScheduledSessions.delete(sessionId);
           scheduleReconciliation(db, sessionId, readMessages);
         }, PREPARE_RETRY_MS).unref?.();
       }).catch((error) => {
-        logIndexingError(sessionId, "reconciliation", error);
+        heapHolder.reconciledSessions.delete(sessionId);
+        logReconciliationStall(sessionId, error instanceof Error ? error.message : String(error));
         if (isDatabaseLockedError(error))
           setTimeout(() => scheduleReconciliation(db, sessionId, readMessages), 1000).unref();
       }).finally(() => {
         heapHolder.reconciliationScheduledSessions.delete(sessionId);
+        if (appendedDuringReconciliation)
+          scheduleReconciliation(db, sessionId, readMessages);
       });
     });
   });
 }
 function scheduleReconciliationCatchup(db, sessionId, readMessages) {
+  if (readMessages.getRevision) {
+    scheduleReconciliation(db, sessionId, readMessages);
+    return;
+  }
   if (typeof readMessages.getCount !== "function") {
     scheduleReconciliation(db, sessionId, readMessages);
     return;
@@ -5114,6 +5261,7 @@ function scheduleReconciliationCatchup(db, sessionId, readMessages) {
 }
 function scheduleClearAndReindex(db, sessionId, readMessages) {
   heapHolder.reconciledSessions.delete(sessionId);
+  heapHolder.reconciledSnapshots.delete(sessionId);
   heapHolder.reconciliationScheduledSessions.delete(sessionId);
   clearCompletedIncrementalKeys(sessionId);
   const existing = heapHolder.clearAndReindexScheduledSessions.get(sessionId);
@@ -5131,6 +5279,7 @@ function scheduleClearAndReindex(db, sessionId, readMessages) {
           return;
         heapHolder.clearAndReindexScheduledSessions.delete(sessionId);
         heapHolder.reconciledSessions.delete(sessionId);
+        heapHolder.reconciledSnapshots.delete(sessionId);
         clearCompletedIncrementalKeys(sessionId);
         clearIndexedMessages(db, sessionId);
         cleared = true;
@@ -6160,6 +6309,20 @@ function resolveTodowriteAvailability(sessionId) {
 }
 
 // src/hooks/magic-context/degraded-pass-refusal.ts
+function describeDegradedPassFailure(site, cause) {
+  const details = [site];
+  const seen = new Set;
+  while (cause !== undefined && cause !== null && !seen.has(cause)) {
+    seen.add(cause);
+    const current = cause;
+    const detail = typeof current.site === "string" ? current.site : typeof current.message === "string" ? current.message : String(cause);
+    if (!details.includes(detail))
+      details.push(detail);
+    cause = current.cause;
+  }
+  return `Magic Context could not safely prepare this turn [${userFacingFailureCode("transform_pass_degraded")}] (${details.join(": ")}). This request was not sent.`;
+}
+
 class DegradedPassRefusalError extends Error {
   site;
   code = "DEGRADED_PASS_REFUSAL";
@@ -6167,7 +6330,7 @@ class DegradedPassRefusalError extends Error {
   estimatedTokens;
   contextLimitTokens;
   constructor(site, options) {
-    super(renderUserFacingFailure("transform_pass_degraded", "plain"), {
+    super(describeDegradedPassFailure(site, options?.cause), {
       cause: options?.cause
     });
     this.site = site;
@@ -7092,7 +7255,7 @@ function searchMessagesInSnapshot(args, sessionFirst) {
       const filtered = rows.slice(0, limit);
       return filtered.map((row, rank) => ({
         source: "message",
-        content: previewText(row.content),
+        content: matchedSearchSnippet(row.content, args.query) || previewText(row.content),
         score: linearDecayScore(rank, filtered.length),
         messageOrdinal: row.messageOrdinal,
         messageId: row.messageId,
@@ -7167,7 +7330,7 @@ function searchMessagesInSnapshot(args, sessionFirst) {
     const ranked = [...fused.values()].sort((a, b) => b.score !== a.score ? b.score - a.score : a.row.messageOrdinal - b.row.messageOrdinal).slice(0, resultLimit);
     return ranked.map((entry, rank) => ({
       source: "message",
-      content: previewText(entry.row.content),
+      content: matchedSearchSnippet(entry.row.content, args.query) || previewText(entry.row.content),
       score: linearDecayScore(rank, ranked.length),
       messageOrdinal: entry.row.messageOrdinal,
       messageId: entry.row.messageId,
@@ -7484,7 +7647,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     if (options.diagnostics) {
       options.diagnostics.suppressedLiveMessageMatches = outcome.suppressedLiveMessageMatches;
     }
-    messageResults = outcome.results;
+    messageResults = outcome.results.filter((result) => result.messageId !== options.excludeMessageId);
   }
   const workspace = resolveSearchWorkspaceContext(db, projectPath);
   const [memoryOutcome, primerResults, noteResults] = await Promise.all([
@@ -7539,6 +7702,12 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       }).immediate();
     }
   }
+  if (options.autoHint) {
+    return results.map((result) => ({
+      ...result,
+      relevanceScore: cleanSearchText(result.content).length === 0 ? 0 : keywordRelevance(trimmedQuery, result.content)
+    }));
+  }
   return results;
 }
 var SEARCH_NOTE_EXPAND_HINT = "Use mmc_expand(start=N-10, end=N) around any note @msg anchor above to read the surrounding conversation context.";
@@ -8158,22 +8327,22 @@ function truncate(text, limit) {
     return normalized;
   return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
 }
-function renderFragment(result, charCap, wordRules) {
+function renderFragment(result, charCap, wordRules, query) {
   switch (result.source) {
     case "memory": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "message": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(query ? matchedSearchSnippet(result.content, query, charCap) : cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "primer": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
     case "note": {
-      const compressed = cavemanCompress(result.content, "ultra", CURRENT_CAVEMAN_RULES, wordRules);
+      const compressed = cavemanCompress(cleanSearchText(result.content), "ultra", CURRENT_CAVEMAN_RULES, wordRules);
       return truncate(compressed, charCap);
     }
   }
@@ -8184,7 +8353,7 @@ function buildAutoSearchHint(results, options = {}) {
   const picks = results.slice(0, maxFragments);
   const lines = [];
   for (const result of picks) {
-    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english");
+    const fragment = renderFragment(result, fragmentCharCap, options.wordRules ?? "english", options.query ?? "");
     if (fragment.length === 0)
       continue;
     lines.push(`- ${fragment}`);
@@ -8207,6 +8376,10 @@ ${trimmedBody}…
   }
   return wrapped;
 }
+function selectAutoSearchResults(results, threshold) {
+  const relevance = (result) => result.relevanceScore ?? result.score;
+  return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
+}
 
 // src/hooks/magic-context/transform-message-helpers.ts
 function isMeaningfulUserMessage(msg) {
@@ -8483,6 +8656,9 @@ async function runAutoSearchHint(args) {
           return null;
         const searchOptions = {
           limit: 10,
+          autoHint: true,
+          maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
+          excludeMessageId: userMsgId,
           memoryEnabled: options.memoryEnabled,
           visibleMemoryIds: options.visibleMemoryIds ?? null,
           sources: ["memory", "message"]
@@ -8507,11 +8683,15 @@ async function runAutoSearchHint(args) {
     if (results.length === 0) {
       return writeNoHintAndReconcile("empty");
     }
-    if (results[0].score < options.scoreThreshold) {
-      sessionLog(sessionId, `auto-search: top score ${results[0].score.toFixed(3)} below threshold ${options.scoreThreshold}`);
+    results = selectAutoSearchResults(results, options.scoreThreshold);
+    if (results.length === 0) {
+      sessionLog(sessionId, `auto-search: no fragment meets relevance threshold ${options.scoreThreshold}`);
       return writeNoHintAndReconcile("below-threshold");
     }
-    const hintText = buildAutoSearchHint(results, { wordRules: options.wordRules });
+    const hintText = buildAutoSearchHint(results, {
+      wordRules: options.wordRules,
+      query: rawPrompt
+    });
     if (!hintText) {
       return writeNoHintAndReconcile("empty");
     }
@@ -8575,6 +8755,30 @@ function getSessionErrorInfo(properties) {
   };
 }
 
+// src/hooks/magic-context/diagnostic-log-state.ts
+var states = new BoundedSessionMap(1000);
+var scope = (sessionId) => `${getMagicContextStorageDir()}\x00${getHarness()}\x00${sessionId}`;
+function diagnosticStateChanged(sessionId, category, state) {
+  const key = scope(sessionId);
+  const previous = states.get(key) ?? new Map;
+  if (previous.get(category) === state)
+    return false;
+  previous.set(category, state);
+  states.set(key, previous);
+  return true;
+}
+function clearDiagnosticLogState(sessionId) {
+  states.delete(scope(sessionId));
+}
+
+// src/hooks/magic-context/nudge-evaluation-log.ts
+function logNudgeEvaluation(sessionId, phase, line) {
+  const category = `${phase}:${line.split(":", 1)[0]}`;
+  const state = line.split(" ").filter((field) => /^(ctx_reduce|band|dampening|verdict|reason|lease)=/.test(field)).join(" ");
+  if (diagnosticStateChanged(sessionId, category, state))
+    sessionLog(sessionId, line);
+}
+
 // src/hooks/magic-context/stripped-command.ts
 function matchStrippedMagicContextCommand(parts) {
   if (parts.length !== 1)
@@ -8763,7 +8967,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
     evaluable: state.evaluable,
     generationInvalidated: state.generationInvalidated
   });
-  sessionLog(sessionId, formatChannel1Evaluation(decision));
+  logNudgeEvaluation(sessionId, "tool-completion", formatChannel1Evaluation(decision));
   setLastNudgeUndropped(args.db, sessionId, decision.nextLastNudge);
   const nextNudgeState = {
     ...nudgeState,
@@ -8776,7 +8980,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
     setChannel1NudgeState(args.db, sessionId, nextNudgeState);
     return;
   }
-  out.output += buildChannel1Reminder(decision.level, decision.undroppedTokens, reclaimableToolOutputCount(state.baselineParts), state.oldestReclaimableToolTags, decision.sticky);
+  out.output += buildChannel1Reminder(decision.level, decision.undroppedTokens, currentReclaimableToolOutputCount(state), state.oldestReclaimableToolTags, decision.sticky);
   setChannel1NudgeState(args.db, sessionId, {
     ...nextNudgeState,
     ordinal: state.realUserTurnCount
@@ -10008,9 +10212,6 @@ class StorageBusyRefusalError extends Error {
   }
 }
 
-// src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash3 } from "node:crypto";
-
 // src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
 
@@ -10152,6 +10353,90 @@ ${BASE_INTRO(memoryEnabled, temporalAwarenessEnabled)}${cavemanWarning}
 ${SELF_TAG_GUIDANCE}${languageGuidance}`;
 }
 
+// src/features/magic-context/transform-decision-log.ts
+var canonicalReasons = new Set([
+  "system_hash",
+  "model_change",
+  "ttl_idle",
+  "explicit_flush",
+  "max_mutation_id",
+  "first_render",
+  "pressure_refold",
+  "upgrade_state",
+  "cached_m1_missing",
+  "project_change",
+  "compartment_render_epoch",
+  "m1_delta",
+  "ttl_expiry",
+  "epoch_change",
+  "coverage_fold",
+  "profile_transition",
+  "host_compaction"
+]);
+var piReasonAliases = {
+  pending_mutations: "max_mutation_id",
+  renderer_upgrade: "upgrade_state",
+  cache_invalid: "cached_m1_missing",
+  drift: "pressure_refold"
+};
+var sharedReasonAliases = {
+  model_key: "model_change",
+  pressure: "pressure_refold"
+};
+var pendingDecisionBySession = new Map;
+var pendingPiDecisionBySession = new Map;
+var lastBoundMessageIdBySession = new Map;
+var scheduledWriteTokensBySession = new Map;
+var systemHashChangedSessions = new Set;
+var piSystemHashChangedSessions = new Set;
+var unbustedPassBySession = new Map;
+var newestInputAssistantBySession = new Map;
+var stagedV2DecisionBySession = new Map;
+function normalizeMaterializeReason(harness, reason, rematerialized) {
+  const raw = typeof reason === "string" ? reason.trim() : "";
+  if (raw.length > 0) {
+    const alias = sharedReasonAliases[raw] ?? (harness === "pi" ? piReasonAliases[raw] : undefined) ?? undefined;
+    if (alias)
+      return alias;
+    if (canonicalReasons.has(raw))
+      return raw;
+    return null;
+  }
+  return rematerialized ? "pressure_refold" : null;
+}
+function clearOpenCodePendingTransformDecision(sessionId, inputMessages) {
+  pendingDecisionBySession.delete(sessionId);
+  unbustedPassBySession.delete(sessionId);
+  if (!inputMessages)
+    return;
+  let newestAssistant = "";
+  for (const message of inputMessages) {
+    const id = message.info?.id;
+    if (message.info?.role !== "assistant" || typeof id !== "string")
+      continue;
+    if (id > newestAssistant)
+      newestAssistant = id;
+  }
+  newestInputAssistantBySession.set(sessionId, newestAssistant);
+}
+function noteSystemPromptHashChange(sessionId) {
+  systemHashChangedSessions.add(sessionId);
+}
+function noteOpenCodeUnbustedPass(sessionId, decision) {
+  unbustedPassBySession.set(sessionId, decision);
+}
+var IDLE_EXPIRY_REASONS = new Set([
+  "ttl_idle",
+  "ttl_expiry"
+]);
+function recordPendingTransformDecision(sessionId, decision) {
+  if (!decision.bustedThisPass) {
+    pendingDecisionBySession.delete(sessionId);
+    return;
+  }
+  pendingDecisionBySession.set(sessionId, decision);
+}
+
 // src/hooks/magic-context/system-prompt-dates.ts
 function replaceHostDates(prompt, replace) {
   const fields = /<(plugin-env|environment|env)>[\s\S]*?<\/\1>|Today's date: [^\r\n<]+/g;
@@ -10169,6 +10454,35 @@ function systemPromptDates(prompt, sticky) {
   return { live: values.length ? JSON.stringify(values) : undefined, stable };
 }
 
+// src/hooks/magic-context/system-prompt-sticky-date.ts
+var STICKY_DATE_KEY = "systemPromptStickyDate";
+function readPersistedSystemPromptStickyDate(db, sessionId) {
+  try {
+    const saved = readReplayEnvelope(db, sessionId, "read")[STICKY_DATE_KEY];
+    return typeof saved === "string" && saved.length > 0 ? saved : undefined;
+  } catch (error) {
+    sessionLog(sessionId, "system prompt sticky date record unreadable:", error);
+    return;
+  }
+}
+function persistSystemPromptStickyDate(db, sessionId, stickyDate) {
+  try {
+    const written = updateReplayDocument(db, sessionId, (doc) => {
+      if (doc[STICKY_DATE_KEY] === stickyDate)
+        return false;
+      doc.version = 2;
+      doc[STICKY_DATE_KEY] = stickyDate;
+      return true;
+    });
+    if (!written)
+      sessionLog(sessionId, "system prompt sticky date record not written");
+    return written;
+  } catch (error) {
+    sessionLog(sessionId, "system prompt sticky date record write failed:", error);
+    return false;
+  }
+}
+
 // src/hooks/magic-context/system-date-refresh.ts
 var channels = new WeakMap;
 var outputUpdates = new WeakMap;
@@ -10239,6 +10553,7 @@ function beginSystemDateRequest(history, sessionId, stage, turnId, identity) {
       systemDone: false,
       messagesSeen: false,
       permitted: undefined,
+      signedThinkingKept: undefined,
       ambiguous: identity === undefined && (turnId === undefined || sameTurn)
     };
     const blocked = [...requests.values()].filter((candidate) => !candidate.explicit && candidate.ambiguous && !(candidate.systemSeen && candidate.messagesSeen) && candidate.turnId === turnId).length;
@@ -10261,6 +10576,10 @@ function systemDateRefreshPermission(history, request) {
   const current = state(history, request);
   return current?.ambiguous ? undefined : current?.permitted;
 }
+function systemDateSignedThinkingKept(history, request) {
+  const current = state(history, request);
+  return current?.ambiguous ? undefined : current?.signedThinkingKept;
+}
 function waitForSystemDateRefresh(history, request, apply) {
   const current = state(history, request);
   if (!current)
@@ -10275,7 +10594,7 @@ function retire(history, current) {
   if (unpairable) {
     const apply = current.waiting;
     current.waiting = undefined;
-    apply?.(false);
+    apply?.(false, undefined);
   }
   const channel = channels.get(history);
   const requests = channel?.get(current.sessionId);
@@ -10283,14 +10602,15 @@ function retire(history, current) {
   if (requests?.size === 0)
     channel?.delete(current.sessionId);
 }
-function finishSystemDateRefresh(history, request, permitted) {
+function finishSystemDateRefresh(history, request, permitted, signedThinkingKept) {
   const current = state(history, request);
   if (!current)
     return;
   current.permitted = current.ambiguous ? false : permitted;
+  current.signedThinkingKept = current.ambiguous ? undefined : signedThinkingKept;
   const apply = current.waiting;
   current.waiting = undefined;
-  apply?.(current.permitted);
+  apply?.(current.permitted, current.signedThinkingKept);
   retire(history, current);
 }
 function finishSystemDateHook(history, request) {
@@ -10326,6 +10646,15 @@ function createSystemPromptHashHandler(deps) {
   });
   const guidanceEpochs = createPromptSurfaceGuidanceEpochCache(promptSurfaceRuntime);
   const stickyDateBySession = new Map;
+  const recordedStickyDateBySession = new Map;
+  const recordedStickyDate = (sessionId) => {
+    let recorded = recordedStickyDateBySession.get(sessionId);
+    if (recorded === undefined) {
+      recorded = readPersistedSystemPromptStickyDate(deps.db, sessionId) ?? null;
+      recordedStickyDateBySession.set(sessionId, recorded);
+    }
+    return recorded ?? undefined;
+  };
   const processSystemPrompt = async (input, output) => {
     const sessionId = input.sessionID;
     if (!sessionId)
@@ -10394,31 +10723,50 @@ function createSystemPromptHashHandler(deps) {
     const hasPersistedHash = previousHash !== "" && previousHash !== "0";
     if (!hasPersistedHash)
       stickyDateBySession.delete(sessionId);
-    const stickyDate = stickyDateBySession.get(sessionId);
+    let stickyDate = stickyDateBySession.get(sessionId);
+    if (stickyDate === undefined && hasPersistedHash) {
+      const recorded = recordedStickyDate(sessionId);
+      const live = systemPromptDates(liveSystemContent).live;
+      if (recorded !== undefined && live !== undefined && recorded !== live && systemPromptFingerprint(systemPromptDates(liveSystemContent, recorded).stable, promptSurface.preset) === previousHash) {
+        stickyDate = recorded;
+        stickyDateBySession.set(sessionId, recorded);
+      }
+    }
+    const setStickyDate = (value) => {
+      stickyDateBySession.set(sessionId, value);
+      if (value !== recordedStickyDate(sessionId)) {
+        if (persistSystemPromptStickyDate(deps.db, sessionId, value))
+          recordedStickyDateBySession.set(sessionId, value);
+      }
+    };
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
-    const stableCandidateHash = createHash3("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = systemPromptFingerprint(stableCandidate, promptSurface.preset);
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
+    const signedThinkingKept = systemDateSignedThinkingKept(deps.historyRefreshSessions, dateRequest);
+    const prefixBoundModel = isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID);
+    const thinkingAllowsDate = (kept) => prefixBoundModel ? kept === false : kept !== true;
+    const systemDateMayMove = (rewrite, kept) => (rewrite || idleCacheExpired) && thinkingAllowsDate(kept);
     let deferredDateRefresh = false;
-    if (currentDate && stickyDate && currentDate !== stickyDate && isCacheBusting && !idleCacheExpired && !contentOrPresetChanged && !requestMessagesFinal) {
+    if (currentDate && stickyDate && currentDate !== stickyDate && (isCacheBusting || idleCacheExpired && isPrefixBoundThinkingModel(liveModel?.providerID, liveModel?.modelID)) && rewritePermission === undefined && !contentOrPresetChanged && !requestMessagesFinal) {
       const liveElements = [...output.system];
-      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted) => {
-        if (!permitted) {
+      deferredDateRefresh = waitForSystemDateRefresh(deps.historyRefreshSessions, dateRequest, (permitted, keptSignedThinking) => {
+        if (!systemDateMayMove(permitted, keptSignedThinking)) {
           deps.systemPromptRefreshSessions.add(sessionId);
           return;
         }
         try {
           const content = liveElements.join(`
 `);
-          const hash = createHash3("md5").update(promptSurfaceHashMaterial(content, promptSurface.preset)).digest("hex");
+          const hash = systemPromptFingerprint(content, promptSurface.preset);
           updateSessionMeta(deps.db, sessionId, {
             systemPromptHash: hash,
             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);
@@ -10429,12 +10777,12 @@ function createSystemPromptHashHandler(deps) {
         }
       });
     }
-    const dateMayAdvance = idleCacheExpired || contentOrPresetChanged || isCacheBusting && !deferredDateRefresh && (dateRequest ? rewritePermission === true : rewritePermission !== false);
+    const dateMayAdvance = thinkingAllowsDate(signedThinkingKept) && (contentOrPresetChanged || !deferredDateRefresh && systemDateMayMove(isCacheBusting && (dateRequest ? rewritePermission === true : rewritePermission !== false), signedThinkingKept));
     if (currentDate && !stickyDate) {
-      stickyDateBySession.set(sessionId, currentDate);
+      setStickyDate(currentDate);
     } else if (currentDate && stickyDate && currentDate !== stickyDate) {
       if (dateMayAdvance) {
-        stickyDateBySession.set(sessionId, currentDate);
+        setStickyDate(currentDate);
         sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${currentDate} (cache-busting pass)`);
       } else {
         let offset = 0;
@@ -10452,7 +10800,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash3("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = systemPromptFingerprint(systemContent, promptSurface.preset);
     recordSystemPromptForRequest(sessionId, currentLkgRequestIdentity(sessionId), currentHash, deps.db, previousHash !== currentHash ? !deps.historyRefreshSessions.has(sessionId) : undefined, deps.historyRefreshSessions, deps.pendingMaterializationSessions);
     if (!sessionMetaEarly) {
       return;
@@ -10460,6 +10808,7 @@ function createSystemPromptHashHandler(deps) {
     const sessionMeta = sessionMetaEarly;
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
       sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : requestMessagesFinal ? "adopting on the request whose messages are already final" : "triggering flush"}`);
+      noteSystemPromptHashChange(sessionId);
       if (!adoptSystemChange) {
         deps.historyRefreshSessions.add(sessionId);
         deps.systemPromptRefreshSessions.add(sessionId);
@@ -10488,7 +10837,7 @@ function createSystemPromptHashHandler(deps) {
         sessionLog(sessionId, "system prompt meta persist failed (fail-open):", error);
       }
     }
-    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged || !currentDate || currentDate === stickyDate || !dateRequest || rewritePermission === true)) {
+    if (isCacheBusting && !deferredDateRefresh && (contentOrPresetChanged && thinkingAllowsDate(signedThinkingKept) || !currentDate || currentDate === stickyDate || !dateRequest && thinkingAllowsDate(signedThinkingKept) || rewritePermission === true && thinkingAllowsDate(signedThinkingKept))) {
       deps.systemPromptRefreshSessions.delete(sessionId);
     }
   };
@@ -10502,6 +10851,7 @@ function createSystemPromptHashHandler(deps) {
   return {
     handler,
     clearSession: (sessionId) => {
+      recordedStickyDateBySession.delete(sessionId);
       clearSystemDateRefresh(deps.historyRefreshSessions, sessionId);
       guidanceEpochs.clear(sessionId);
       clearSystemPromptHashSession(sessionId, {
@@ -10520,10 +10870,16 @@ class MaintenanceLauncher {
   constructor(deps) {
     this.deps = deps;
   }
+  modelConfigured() {
+    return hasMaintenancePrimary(this.deps.getConfig().maintenance);
+  }
   maybeLaunch(signals) {
     if (!this.deps.getConfig().maintenance.enabled) {
       return { launched: false, reason: "maintenance-disabled" };
     }
+    if (!this.modelConfigured()) {
+      return { launched: false, reason: "maintenance-model-unconfigured" };
+    }
     if (this.runInFlight) {
       return { launched: false, reason: "run-in-flight-local" };
     }
@@ -10553,6 +10909,9 @@ class MaintenanceLauncher {
     if (!this.deps.getConfig().maintenance.enabled) {
       return { launched: false, reason: "maintenance-disabled" };
     }
+    if (!this.modelConfigured()) {
+      return { launched: false, reason: "maintenance-model-unconfigured" };
+    }
     if (this.runInFlight) {
       return { launched: false, reason: "run-in-flight-local" };
     }
@@ -10692,63 +11051,6 @@ function hasRecordedSessionProjectIdentity(db, sessionId) {
   return row?.found === 1;
 }
 
-// src/features/magic-context/transform-decision-log.ts
-var canonicalReasons = new Set([
-  "system_hash",
-  "model_change",
-  "ttl_idle",
-  "explicit_flush",
-  "max_mutation_id",
-  "first_render",
-  "pressure_refold",
-  "upgrade_state",
-  "cached_m1_missing",
-  "project_change",
-  "compartment_render_epoch",
-  "m1_delta",
-  "ttl_expiry",
-  "epoch_change",
-  "coverage_fold",
-  "profile_transition",
-  "host_compaction"
-]);
-var piReasonAliases = {
-  pending_mutations: "max_mutation_id",
-  renderer_upgrade: "upgrade_state",
-  cache_invalid: "cached_m1_missing",
-  drift: "pressure_refold"
-};
-var sharedReasonAliases = {
-  model_key: "model_change",
-  pressure: "pressure_refold"
-};
-var pendingDecisionBySession = new Map;
-var pendingPiDecisionBySession = new Map;
-var lastBoundMessageIdBySession = new Map;
-var scheduledWriteTokensBySession = new Map;
-function normalizeMaterializeReason(harness, reason, rematerialized) {
-  const raw = typeof reason === "string" ? reason.trim() : "";
-  if (raw.length > 0) {
-    const alias = sharedReasonAliases[raw] ?? (harness === "pi" ? piReasonAliases[raw] : undefined) ?? undefined;
-    if (alias)
-      return alias;
-    if (canonicalReasons.has(raw))
-      return raw;
-    return null;
-  }
-  return rematerialized ? "pressure_refold" : null;
-}
-function clearOpenCodePendingTransformDecision(sessionId) {
-  pendingDecisionBySession.delete(sessionId);
-}
-function recordPendingTransformDecision(sessionId, decision) {
-  if (!decision.bustedThisPass) {
-    pendingDecisionBySession.delete(sessionId);
-    return;
-  }
-  pendingDecisionBySession.set(sessionId, decision);
-}
-
 // src/hooks/magic-context/cache-busting-signals.ts
 function canConsumeDeferredOnThisPass(args) {
   if (args.justAwaitedPublication)
@@ -11422,12 +11724,12 @@ function buildTriggerInMemoryTail(db, sessionId, messages) {
 function getProactiveCompartmentTriggerPercentage(executeThresholdPercentage) {
   return Math.max(0, executeThresholdPercentage - PROACTIVE_TRIGGER_OFFSET_PERCENTAGE);
 }
-function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, keepReasoningTokens, clearedReasoningThroughTag, canClearReasoning, liveBudgetCutoff) {
+function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, keepReasoningTokens, clearedReasoningThroughTag, canClearReasoning, liveBudgetCutoff, eligiblePendingDropTagIds) {
   const totalActiveBytes = activeTags.reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   if (totalActiveBytes === 0)
     return null;
   let droppableBytes = 0;
-  const pendingDrops = getPendingOps(db, sessionId).filter((op) => op.operation === "drop");
+  const pendingDrops = getPendingOps(db, sessionId).filter((op) => op.operation === "drop" && eligiblePendingDropTagIds?.has(op.tagId) === true);
   const pendingDropTagIds = new Set(pendingDrops.map((op) => op.tagId));
   if (pendingDrops.length > 0) {
     droppableBytes += activeTags.filter((tag) => pendingDropTagIds.has(tag.tagNumber)).reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
@@ -11555,7 +11857,7 @@ 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, storedTotalsExcludeToolTags) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds, storedTotalsExcludeToolTags) {
   if (sessionMeta.compartmentInProgress) {
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -11619,7 +11921,7 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
-  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff);
+  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff, eligiblePendingDropTagIds);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
   const rideLabel = reclaimRide ? reclaimRideLabel(reclaimRide) : "ride=none";
   const dropsCanLand = reclaimRide !== undefined && hasReclaimRide(reclaimRide);
@@ -11703,6 +12005,12 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
   };
 }
 
+// src/hooks/magic-context/compartment-trigger-error.ts
+function recordCompartmentTriggerError(passOutcome, sessionId, error, log = sessionLog) {
+  passOutcome.record("compartment-trigger-failure");
+  log(sessionId, "compartment trigger failed (non-fatal):", error);
+}
+
 // src/hooks/magic-context/pass-outcome.ts
 var PASS_DEGRADATION_EFFECTS = {
   "store-generation-rebase-failure": "changes-request",
@@ -11719,6 +12027,8 @@ var PASS_DEGRADATION_EFFECTS = {
   "stale-reduce-strip-exception": "changes-request",
   "image-strip-exception": "changes-request",
   "m0-m1-injection-degradation": "changes-request",
+  "host-instruction-retention-read-failure": "changes-request",
+  "host-instruction-retention-persistence-failure": "changes-request",
   "m0-m1-fallback-failure": "changes-request",
   "compaction-marker-drain-failure": "changes-request",
   "auto-search-timeout": "served",
@@ -11763,6 +12073,37 @@ function createPassOutcome() {
   };
 }
 
+// src/hooks/magic-context/render-options.ts
+function createM0RenderOptions(controls, contextUsage, modelKey, resolvedContextLimit, projectPath) {
+  return {
+    projectPath: controls.memoryConfig?.enabled ? projectPath : undefined,
+    memoryEnabled: controls.memoryConfig?.enabled,
+    memoryInjectionBudgetTokens: controls.memoryConfig?.injectionBudgetTokens,
+    temporalAwareness: controls.experimentalTemporalAwareness,
+    historyBudgetTokens: resolveHistoryBudgetTokens(controls.historyBudgetPercentage, contextUsage, controls.executeThresholdPercentage, modelKey, controls.executeThresholdTokens, resolvedContextLimit),
+    historyBudgetPolicyIdentity: historyBudgetPolicyIdentity(controls.historyBudgetPercentage, controls.executeThresholdPercentage, modelKey, controls.executeThresholdTokens)
+  };
+}
+function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
+  if (!historyBudgetPercentage) {
+    return;
+  }
+  let contextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
+  if (contextLimit <= 0) {
+    if (contextUsage.percentage <= 0) {
+      return;
+    }
+    contextLimit = contextUsage.inputTokens / (contextUsage.percentage / 100);
+  }
+  if (!Number.isFinite(contextLimit) || contextLimit <= 0) {
+    return;
+  }
+  return Math.floor(contextLimit * (resolveExecuteThreshold(executeThresholdPercentage ?? 65, modelKey, 65, {
+    tokensConfig: executeThresholdTokens,
+    contextLimit
+  }) / 100) * historyBudgetPercentage);
+}
+
 // src/hooks/magic-context/temporal-served-projection.ts
 function readLkgTemporalDecisions(db, sessionId, runtime) {
   const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
@@ -11955,6 +12296,13 @@ async function runCompartmentPhaseImpl(args) {
     return snapshot !== null && hasRunnableCompartmentWindow(snapshot);
   }
   async function awaitCompartmentRun(activeRun, reason) {
+    await Promise.resolve();
+    if (activeRun.inlineJoinTimedOutBudgetMs !== undefined && !activeRun.settled) {
+      historianJoinTimedOut = true;
+      historianJoinBudgetMs = activeRun.inlineJoinTimedOutBudgetMs;
+      sessionLog(args.sessionId, "transform: compartment inline join budget already exhausted for this run — not waiting again");
+      return "timed_out";
+    }
     sessionLog(args.sessionId, reason);
     const timeoutMs = resolveHistorianInlineJoinBudget(args.historianTimeoutMs);
     historianJoinBudgetMs = timeoutMs;
@@ -11970,6 +12318,7 @@ async function runCompartmentPhaseImpl(args) {
         clearTimeout(timer);
     }
     if (result === "timeout") {
+      activeRun.inlineJoinTimedOutBudgetMs = timeoutMs;
       historianJoinTimedOut = true;
       sessionLog(args.sessionId, `transform: compartment await timed out after ${timeoutMs}ms — proceeding without waiting`);
       return "timed_out";
@@ -11978,7 +12327,7 @@ async function runCompartmentPhaseImpl(args) {
     justAwaitedPublication = activeRun.published;
     published = published || activeRun.published;
     const historyReprepareShouldBust = activeRun.published && args.deferredHistoryRefreshSessions.has(args.sessionId);
-    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness);
+    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, historyReprepareShouldBust, args.projectPath, args.injectionBudgetTokens, args.experimentalTemporalAwareness, args.coveredHostInstructions);
     if (historyReprepareShouldBust) {
       rebuiltHistoryThisPass = true;
     }
@@ -12177,33 +12526,119 @@ function resolveSchedulerDecision(scheduler, sessionMeta, contextUsage, sessionI
   }
 }
 
+// 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 && target.canSetContent?.(`[dropped §${number}§]`) !== 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/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
 function applyNewToolDrop(target, options) {
-  if (options.persist && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+  const plan = planNewToolDrop(target, options, !!options.persist);
+  if (!plan)
     return { result: "incomplete", mode: "full" };
+  options.persist?.(plan.mode);
+  return plan.apply();
+}
+function planNewToolDrop(target, options, prepare, plannedRemovals) {
+  if (prepare && (target?.prepareDrop?.() ?? target?.canDrop?.()) === false) {
+    return;
   }
   if (!target) {
-    options.persist?.("full");
-    return { result: "absent", mode: "full" };
+    return { mode: "full", apply: () => ({ result: "absent", mode: "full" }) };
   }
-  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.() === true) {
+  if (options.inWindow && hasSmallToolInput(target) || options.keepSkeleton === true || target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.(plannedRemovals) === true) {
     const strip = target.hasAttachments?.() === true;
-    options.persist?.(strip ? "skeleton_stripped" : "skeleton_real");
+    const mode = strip ? "skeleton_stripped" : "skeleton_real";
     return {
-      result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
-      mode: strip ? "skeleton_stripped" : "skeleton_real"
+      mode,
+      apply: () => ({
+        result: (strip ? target.skeletonStripped?.() : target.skeletonReal?.()) ?? "absent",
+        mode
+      })
     };
   }
-  options.persist?.("full");
-  const result = target.drop?.() ?? "absent";
-  if (result === "truncated" && target.hasAttachments?.() === true) {
-    return { result: target.skeletonStripped?.() ?? "absent", mode: "skeleton_stripped" };
-  }
-  return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+  return {
+    mode: "full",
+    apply: () => {
+      const result = target.drop?.() ?? "absent";
+      if (result === "truncated" && target.hasAttachments?.() === true) {
+        return {
+          result: target.skeletonStripped?.() ?? "absent",
+          mode: "skeleton_stripped"
+        };
+      }
+      return { result, mode: result === "truncated" ? "skeleton_real" : "full" };
+    }
+  };
 }
 function hasSmallToolInput(target) {
   const bytes = target?.inputStringBytes?.() ?? null;
@@ -12285,7 +12720,8 @@ function renderConvertedToolSkeletons(targets, converted) {
   }
   return didMutate;
 }
-function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete) {
+var PENDING_OPERATION_CHUNK_SIZE = 64;
+function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
   let diagnostics;
   const reject = (reason) => {
@@ -12294,163 +12730,188 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
     diagnostics.reasons[reason] = (diagnostics.reasons[reason] ?? 0) + 1;
   };
   let admitted = false;
-  try {
-    db.transaction(() => {
-      admitted = true;
-    }).immediate();
-    {
-      const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
-      const neededTagNumbers = new Set(pendingOps.map((op) => op.tagId));
-      for (const op of syntheticPendingOps)
-        neededTagNumbers.add(op.tagId);
-      const tags = preloadedTags ?? getTagsByNumbers(db, sessionId, (() => {
-        const newest = getNewestToolTagNumbers(db, sessionId, RECENT_TOOL_SKELETON_WINDOW);
-        const numbers = [...neededTagNumbers];
-        for (const tagNumber of newest) {
-          if (!neededTagNumbers.has(tagNumber))
-            numbers.push(tagNumber);
-        }
-        return numbers;
-      })());
-      const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
-      const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
-      const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
-      const opsToApply = [
-        ...pendingOps.map((op) => ({ op, synthetic: false })),
-        ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
-      ];
-      diagnostics = {
-        source: pendingOps.length > 0 && syntheticPendingOps.length > 0 ? "mixed" : syntheticPendingOps.length > 0 ? "synthetic" : "pending",
-        total: opsToApply.length,
-        mutated: 0,
-        persistedWithoutMutation: 0,
-        reasons: {}
-      };
-      const skeletonWindow = new Set(getNewestToolTagNumbers(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
-      for (const { op: pendingOp, synthetic } of opsToApply) {
-        let operationMutated = false;
-        const tagStatus = tagStatusById.get(pendingOp.tagId);
-        if (tagStatus === "compacted" || tagStatus === "dropped") {
-          reject("already_reduced");
-          if (!synthetic)
-            removePendingOp(db, sessionId, pendingOp.tagId);
-          continue;
-        }
-        if (protectedTagIds.has(pendingOp.tagId)) {
-          reject("protected");
-          continue;
-        }
-        const target = targets.get(pendingOp.tagId);
-        if (target?.thinkingDropProtected) {
-          reject("active_thinking");
-          continue;
-        }
-        const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
-        if (synthetic) {
-          if (!isToolTag) {
-            reject("synthetic_non_tool");
-            continue;
-          }
-          if (target?.canDrop?.() !== true) {
-            reject("synthetic_target_not_droppable");
-            continue;
-          }
+  let startedAt = 0;
+  const mutations = [];
+  let drainChunk;
+  let hasMore = false;
+  do {
+    admitted = false;
+    startedAt = 0;
+    try {
+      db.transaction(() => {
+        admitted = true;
+        startedAt = performance.now();
+        if (drainChunk) {
+          drainChunk();
+          return;
         }
-        let shouldPersistDrop = false;
-        const persistDrop = (mode) => {
-          let startedAt = 0;
-          try {
-            db.transaction(() => {
-              startedAt = performance.now();
-              if (mode)
-                updateTagDropMode(db, sessionId, pendingOp.tagId, mode);
-              updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
+        const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+        onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
+        const tags = preloadedTags ?? getTagsByNumbers(db, sessionId, [
+          ...new Set([
+            ...pendingOps.map((op) => op.tagId),
+            ...syntheticPendingOps.map((op) => op.tagId)
+          ])
+        ]);
+        const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
+        const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
+        const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
+        const opsToApply = [
+          ...pendingOps.map((op) => ({ op, synthetic: false })),
+          ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
+        ];
+        diagnostics = {
+          source: pendingOps.length > 0 && syntheticPendingOps.length > 0 ? "mixed" : syntheticPendingOps.length > 0 ? "synthetic" : "pending",
+          total: opsToApply.length,
+          mutated: 0,
+          persistedWithoutMutation: 0,
+          reasons: {}
+        };
+        const skeletonWindow = new Set(preloadedTags ? tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW) : getNewestToolTagNumbers(db, sessionId, RECENT_TOOL_SKELETON_WINDOW));
+        const plannedRemovals = new Set;
+        const removedTagIds = new Set;
+        const record = (mutated) => {
+          if (!diagnostics)
+            return;
+          if (mutated) {
+            didMutateMessage = true;
+            diagnostics.mutated += 1;
+          } else
+            diagnostics.persistedWithoutMutation += 1;
+        };
+        let cursor = 0;
+        drainChunk = () => {
+          const chunk = opsToApply.slice(cursor, cursor + PENDING_OPERATION_CHUNK_SIZE);
+          cursor += chunk.length;
+          hasMore = cursor < opsToApply.length;
+          for (const { op: pendingOp, synthetic } of chunk) {
+            const tagStatus = tagStatusById.get(pendingOp.tagId);
+            if (tagStatus === "compacted" || tagStatus === "dropped") {
+              reject("already_reduced");
               if (!synthetic)
                 removePendingOp(db, sessionId, pendingOp.tagId);
-            }).immediate();
-          } finally {
-            if (startedAt)
-              logSlowWriteTransaction("apply_pending_operation", startedAt);
-          }
-        };
-        if (isToolTag) {
-          if (editMarkerTagIds.has(pendingOp.tagId)) {
-            const strip = target?.hasAttachments?.() === true;
-            if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
-              reject("edit_marker_incomplete");
               continue;
             }
-            persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
-            const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
-            if (markResult === "incomplete" || markResult === "absent") {
-              reject(`edit_marker_${markResult}`);
+            if (removedTagIds.has(pendingOp.tagId)) {
+              reject("drop_incomplete");
               continue;
             }
-            didMutateMessage = true;
-            operationMutated = true;
-            onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "edit_marker" });
-            shouldPersistDrop = true;
-          } else {
-            const { result: dropResult, mode: appliedMode } = applyNewToolDrop(target, {
-              inWindow: skeletonWindow.has(pendingOp.tagId),
-              persist: persistDrop
-            });
-            if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
-              reject(`drop_${dropResult}`);
+            const target = targets.get(pendingOp.tagId);
+            const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
+            if (veto) {
+              reject(veto);
               continue;
             }
-            if (dropResult === "removed" || dropResult === "truncated") {
-              didMutateMessage = true;
-              operationMutated = true;
-              onTagReduced?.({
-                tagNumber: pendingOp.tagId,
-                mode: appliedMode === "full" ? "full" : "truncated"
+            const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
+            if (synthetic) {
+              if (!isToolTag) {
+                reject("synthetic_non_tool");
+                continue;
+              }
+              if (target?.canDrop?.() !== true) {
+                reject("synthetic_target_not_droppable");
+                continue;
+              }
+            }
+            const persistDrop = (mode) => {
+              markTagDropped(db, sessionId, pendingOp.tagId, mode);
+              if (!synthetic)
+                removePendingOp(db, sessionId, pendingOp.tagId);
+            };
+            if (isToolTag) {
+              if (editMarkerTagIds.has(pendingOp.tagId)) {
+                const strip = target?.hasAttachments?.() === true;
+                if (target?.canDrop?.() === false || target?.prepareDrop?.() === false || !target) {
+                  reject("edit_marker_incomplete");
+                  continue;
+                }
+                persistDrop(strip ? "edit_marker_stripped" : "edit_marker");
+                mutations.push(() => {
+                  const markResult = (strip ? target?.editMarkerStripped?.() : target?.editMarker?.()) ?? "absent";
+                  if (markResult === "incomplete" || markResult === "absent") {
+                    reject(`edit_marker_${markResult}`);
+                    return;
+                  }
+                  record(true);
+                  onTagReduced?.({
+                    tagNumber: pendingOp.tagId,
+                    mode: "edit_marker"
+                  });
+                });
+              } else {
+                const plan = planNewToolDrop(target, { inWindow: skeletonWindow.has(pendingOp.tagId) }, true, plannedRemovals);
+                if (!plan) {
+                  reject("drop_incomplete");
+                  continue;
+                }
+                persistDrop(plan.mode);
+                if (plan.mode === "full" && target?.drop) {
+                  target.notePlannedRemoval?.(plannedRemovals);
+                  removedTagIds.add(pendingOp.tagId);
+                }
+                mutations.push(() => {
+                  const { result: dropResult, mode: appliedMode } = plan.apply();
+                  if (dropResult === "incomplete" || synthetic && dropResult !== "removed" && dropResult !== "truncated") {
+                    reject(`drop_${dropResult}`);
+                    return;
+                  }
+                  if (dropResult === "removed" || dropResult === "truncated") {
+                    record(true);
+                    onTagReduced?.({
+                      tagNumber: pendingOp.tagId,
+                      mode: appliedMode === "full" ? "full" : "truncated"
+                    });
+                  } else {
+                    reject(`drop_${dropResult}`);
+                    record(false);
+                  }
+                });
+              }
+            } else if (target) {
+              const replacement = buildReplacementContent(pendingOp.tagId);
+              if (target.canSetContent?.(replacement) === false) {
+                reject("content_unchanged");
+                continue;
+              }
+              persistDrop();
+              mutations.push(() => {
+                const priorContent = target.getContent?.();
+                const changed = target.setContent(replacement);
+                record(changed);
+                if (changed) {
+                  const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
+                  onTagReduced?.({
+                    tagNumber: pendingOp.tagId,
+                    mode: "partial",
+                    removedCharacters: Math.max(0, originalCharacters - replacement.length)
+                  });
+                } else {
+                  reject("content_unchanged");
+                }
               });
-            } else {
-              reject(`drop_${dropResult}`);
+            } else if (!synthetic) {
+              reject("target_absent");
+              persistDrop();
+              mutations.push(() => record(false));
             }
-            shouldPersistDrop = true;
           }
-        } else if (target) {
-          const replacement = buildReplacementContent(pendingOp.tagId);
-          const priorContent = target.getContent?.();
-          persistDrop();
-          const changed = target.setContent(replacement);
-          if (changed) {
-            didMutateMessage = true;
-            operationMutated = true;
-            const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
-            onTagReduced?.({
-              tagNumber: pendingOp.tagId,
-              mode: "partial",
-              removedCharacters: Math.max(0, originalCharacters - replacement.length)
-            });
-          } else {
-            reject("content_unchanged");
-          }
-          shouldPersistDrop = true;
-        } else if (!synthetic) {
-          reject("target_absent");
-          persistDrop();
-          shouldPersistDrop = true;
-        }
-        if (!shouldPersistDrop) {
-          reject("not_persisted");
-          continue;
-        }
-        if (operationMutated)
-          diagnostics.mutated += 1;
-        else
-          diagnostics.persistedWithoutMutation += 1;
+        };
+        drainChunk();
+      }).immediate();
+    } catch (error) {
+      if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
+        sessionLog(sessionId, "pending operations write admission busy; retaining remaining operations for retry");
+        hasMore = false;
+      } else {
+        throw error;
       }
+    } finally {
+      if (startedAt)
+        logSlowWriteTransaction("apply_pending_operations", startedAt);
     }
-  } catch (error) {
-    if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
-      sessionLog(sessionId, "pending operations write admission busy; retaining prior bytes for retry");
-      return false;
-    }
-    throw error;
-  }
+    for (const mutate of mutations.splice(0))
+      mutate();
+  } while (hasMore);
   if (diagnostics) {
     onBatchComplete?.(diagnostics);
     if (diagnostics.total > 0 && diagnostics.mutated === 0) {
@@ -12684,10 +13145,41 @@ function createExistingTagResolver(sessionId, tagger, db) {
 }
 
 // src/hooks/magic-context/transform-stage-logger.ts
-function logTransformTiming(sessionId, stage, startMs, extra) {
-  const elapsed = (performance.now() - startMs).toFixed(1);
+import { AsyncLocalStorage } from "node:async_hooks";
+var SLOW_STAGE_MS = 100;
+var passes = new AsyncLocalStorage;
+async function withTransformTimingSummary(run) {
+  const pass = {
+    stages: [],
+    slow: [],
+    closed: false,
+    sessionId: undefined
+  };
+  return passes.run(pass, async () => {
+    try {
+      return await run();
+    } finally {
+      pass.closed = true;
+      if (pass.sessionId)
+        sessionLog(pass.sessionId, `transform stages: ${pass.stages.join(" ")} slow>=${SLOW_STAGE_MS}ms=[${pass.slow.join(",")}]`);
+    }
+  });
+}
+function logTransformElapsed(sessionId, stage, elapsedMs, extra) {
+  const elapsed = elapsedMs.toFixed(1);
   const suffix = extra ? ` ${extra}` : "";
-  sessionLog(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
+  const pass = passes.getStore();
+  if (pass && !pass.closed) {
+    pass.sessionId = sessionId;
+    pass.stages.push(`${stage}=${elapsed}ms${extra ? `(${extra})` : ""}`);
+    if (elapsedMs >= SLOW_STAGE_MS)
+      pass.slow.push(stage);
+  }
+  if (elapsedMs >= SLOW_STAGE_MS)
+    sessionLog(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
+}
+function logTransformTiming(sessionId, stage, startMs, extra) {
+  logTransformElapsed(sessionId, stage, performance.now() - startMs, extra);
 }
 
 // src/hooks/magic-context/tag-messages.ts
@@ -13065,13 +13557,19 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         }));
         accAssignTag += performance.now() - _tAssignText;
         const persistedSource = sourceContents.get(tagId);
-        if (persistedSource !== undefined) {
-          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource) : persistedSource;
+        if (persistedSource !== undefined && !options.refreshSourceContents) {
+          textPart.text = options.normalizeRestoredAssistantText && message.info.role === "assistant" ? options.normalizeRestoredAssistantText(persistedSource, message.info.providerID) : persistedSource;
         } else {
           const sourceContent = stripTagPrefix(textPart.text);
-          if (sourceContent.trim().length > 0) {
+          if (sourceContent.trim().length > 0 || options.refreshSourceContents) {
             const _tSaveText = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
+            if (options.refreshSourceContents) {
+              db.transaction(() => {
+                replaceSourceContent(db, sessionId, tagId, sourceContent);
+                db.prepare("UPDATE tags SET byte_size = ?, token_count = ? WHERE session_id = ? AND tag_number = ?").run(byteSize(sourceContent), estimateTextTagTokenCount(sourceContent), sessionId, tagId);
+              }).immediate();
+            } else
+              saveSourceContent(db, sessionId, tagId, sourceContent);
             accSaveSource += performance.now() - _tSaveText;
           }
         }
@@ -13090,6 +13588,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           dropReasoningParts: thinkingParts,
           mutationParts: [{ message, part: textPart }],
           textPrefix: skipPrefixInjection ? "" : prependTag(tagId, ""),
+          canSetContent: (content) => textPart.text !== content,
           setContent: (content, options) => {
             if (textPart.text === content)
               return false;
@@ -13147,26 +13646,20 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         const filePart = part;
         const messageParts = message.parts;
         const contentId = `${messageId}:file${partIndex}`;
-        const existingTagId = resolver.resolve(messageId, "file", contentId, fileOrdinal);
-        const _tAssignFile = performance.now();
-        const tagId = existingTagId ?? tagger.assignTag(sessionId, contentId, "file", byteSize(filePart.url), db, 0, null, 0, null, () => ({
-          tokenCount: estimateTextTagTokenCount(filePart.url),
-          inputTokenCount: null,
-          reasoningTokenCount: null
-        }));
-        accAssignTag += performance.now() - _tAssignFile;
-        if (existingTagId === undefined) {
-          const sourceContent = buildFileSourceContent(message.parts);
-          if (sourceContent) {
-            const _tSaveFile = performance.now();
-            saveSourceContent(db, sessionId, tagId, sourceContent);
-            accSaveSource += performance.now() - _tSaveFile;
-          }
-        }
+        const existingTagId = resolver.resolve(messageId, "file", contentId, fileOrdinal) ?? getTagNumberByMessageId(db, sessionId, contentId) ?? undefined;
+        fileOrdinal += 1;
+        if (existingTagId === undefined)
+          continue;
+        const tagId = existingTagId;
+        tagger.bindTag(sessionId, contentId, tagId);
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         targets.set(tagId, {
           message,
           mutationParts: [{ message, part: filePart }],
+          canSetContent: (content) => {
+            const current = messageParts[partIndex];
+            return !(typeof current === "object" && current !== null && ("text" in current) && current.text === content);
+          },
           setContent: (content) => {
             const prev = messageParts[partIndex];
             const prevText = typeof prev === "object" && prev !== null && "text" in prev ? prev.text : "";
@@ -13179,7 +13672,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             return true;
           }
         });
-        fileOrdinal += 1;
       }
     }
     if (message.info.role === "assistant" && !messageHasTextPart) {
@@ -13208,6 +13700,23 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
     normalizationTargets
   };
 }
+// src/features/magic-context/storage-host-instruction-retention.ts
+var NAMESPACE3 = "hostInstructionRetention";
+function isHostInstructionRetentionOn(db, sessionId) {
+  const lane = readReplayEnvelope(db, sessionId)[NAMESPACE3];
+  return typeof lane === "object" && lane !== null && lane.on === true;
+}
+function markHostInstructionRetention(db, sessionId) {
+  return updateReplayDocument(db, sessionId, (doc) => {
+    const lane = doc[NAMESPACE3];
+    if (typeof lane === "object" && lane !== null && lane.on === true)
+      return false;
+    doc.version = 2;
+    doc[NAMESPACE3] = { on: true };
+    return true;
+  });
+}
+
 // src/hooks/magic-context/channel2-cycle.ts
 function rearmChannel2AfterCoverageAdvancingHardFold(input) {
   if (input.compactionOff || !input.foldExecuted || input.previousCoverage === null || input.currentCoverage === null || input.currentCoverage <= input.previousCoverage) {
@@ -13774,7 +14283,7 @@ function buildEditSupersessionReclaim(input) {
       seenFile.add(filePath);
       continue;
     }
-    if (input.recentMessageIds && (tag.toolOwnerMessageId === null || input.recentMessageIds.has(tag.toolOwnerMessageId))) {
+    if (tag.tagNumber > input.watermark || input.recentMessageIds && (tag.toolOwnerMessageId === null || input.recentMessageIds.has(tag.toolOwnerMessageId))) {
       continue;
     }
     if (realPendingTagIds.has(tag.tagNumber))
@@ -13822,6 +14331,51 @@ async function waitForTagOwners(db, sessionId, ratio, _waitMs = 250) {
   return prewarmTagOwners(db, sessionId, ratio);
 }
 
+// src/shared/reclaim-distance.ts
+var RECLAIM_DISTANCE_USER_TURNS = 3;
+var RECLAIM_DISTANCE_WINDOW_FRACTION = 0.25;
+function isReclaimUserTurn(args) {
+  return args.role === "user" && !args.syntheticHead && !args.synthetic && !args.ignored && args.parts.some((part) => {
+    if (part.synthetic || part.ignored)
+      return false;
+    if (part.kind !== "text" && part.kind !== "image" && part.kind !== "file")
+      return false;
+    if (part.kind !== "text")
+      return true;
+    return stripReclaimMcText(part.text ?? "").trim().length > 0;
+  });
+}
+function stripReclaimMcText(text) {
+  return text.replace(/^§\d+§\s*/, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, (reminder) => /^(?:Your next step: call ctx_reduce on the outputs you've already used|Still unstamped:|Housekeeping: .* are reclaimable\. Stamp each output with ctx_reduce|.* are reclaimable\. Make a ctx_reduce pass now|.* are still unstamped\. Call ctx_reduce now)/.test(reminder.slice("<system-reminder>".length).trimStart()) ? "" : reminder).replace(/<instruction name="deferred_notes">[\s\S]*?<\/instruction>/g, "");
+}
+function farBehindToolBookmark(entries, usableWindow) {
+  let newerTurns = 0;
+  let newerTokens = 0;
+  const farTags = [];
+  let firstYoungTag = Infinity;
+  const seenOutputs = new Set;
+  const tokenDistance = usableWindow > 0 && Number.isFinite(usableWindow) ? usableWindow * RECLAIM_DISTANCE_WINDOW_FRACTION : Infinity;
+  for (let index = entries.length - 1;index >= 0; index--) {
+    const entry = entries[index];
+    if (!entry)
+      continue;
+    const tag = entry.toolOutputTag;
+    if (tag !== undefined && !seenOutputs.has(tag)) {
+      seenOutputs.add(tag);
+      if (newerTurns >= RECLAIM_DISTANCE_USER_TURNS || newerTokens >= tokenDistance) {
+        farTags.push(tag);
+      } else {
+        firstYoungTag = Math.min(firstYoungTag, tag);
+      }
+    }
+    if (entry.userTurn)
+      newerTurns++;
+    if (Number.isFinite(entry.tokens) && entry.tokens > 0)
+      newerTokens += entry.tokens;
+  }
+  return farTags.reduce((bookmark, tag) => tag < firstYoungTag ? Math.max(bookmark, tag) : bookmark, 0);
+}
+
 // src/hooks/magic-context/tool-reclaim.ts
 function buildSyntheticToolReclaimOps(input) {
   const watermark = Math.max(0, input.watermark);
@@ -13853,10 +14407,74 @@ function buildSyntheticToolReclaimOps(input) {
   }
   return synthetic;
 }
-function advanceToolReclaimWatermarkToCurrentMax(db, sessionId) {
-  const maxTagNumber = getMaxTagNumberBySession(db, sessionId);
-  advanceToolReclaimWatermark(db, sessionId, maxTagNumber);
-  return maxTagNumber;
+function advanceToolReclaimWatermarkByDistance(db, sessionId, entries, usableWindow) {
+  const bookmark = farBehindToolBookmark(entries, usableWindow);
+  advanceToolReclaimWatermark(db, sessionId, bookmark);
+  return bookmark;
+}
+function toolReclaimDistanceEntries(messages, targets) {
+  const outputTags = new Map;
+  for (const [tag, target] of targets) {
+    for (const location of target.mutationParts ?? []) {
+      const part = distancePart(location.part);
+      if (part.kind === "tool_result" || part.kind === "tool")
+        outputTags.set(location.part, tag);
+    }
+  }
+  const entries = [];
+  for (const message of messages) {
+    const parts = message.parts.map(distancePart);
+    let userTurn = isReclaimUserTurn({ ...message.info, parts });
+    for (const [index, part] of parts.entries()) {
+      const authored = isReclaimUserTurn({ role: "user", parts: [part] });
+      entries.push({
+        tokens: message.info.syntheticHead ? 0 : estimateTokens(stripReclaimMcText(part.text ?? "")) + part.imageTokens,
+        userTurn: userTurn && authored,
+        toolOutputTag: outputTags.get(message.parts[index])
+      });
+      if (authored)
+        userTurn = false;
+    }
+  }
+  return entries;
+}
+function distancePart(raw) {
+  if (!raw || typeof raw !== "object")
+    return { kind: "structural", imageTokens: 0 };
+  const part = raw;
+  const provenance = { synthetic: part.synthetic === true, ignored: part.ignored === true };
+  if (typeof part.getText === "function") {
+    const text = part.getText();
+    return {
+      ...provenance,
+      kind: String(part.kind),
+      text: typeof text === "string" ? text : undefined,
+      imageTokens: typeof part.imageTokens === "function" ? Number(part.imageTokens()) : 0
+    };
+  }
+  const metadata = { ...provenance, imageTokens: estimatePartImageTokens(raw) };
+  if (part.type === "tool") {
+    const state = part.state;
+    return {
+      ...metadata,
+      kind: "tool",
+      text: `${JSON.stringify(state?.input ?? {})}
+${typeof state?.output === "string" ? state.output : JSON.stringify(state?.output ?? "")}`
+    };
+  }
+  if (part.type === "tool_use")
+    return { ...metadata, kind: "tool_use", text: JSON.stringify(part.input ?? {}) };
+  if (part.type === "tool_result")
+    return {
+      ...metadata,
+      kind: "tool_result",
+      text: typeof part.content === "string" ? part.content : JSON.stringify(part.content ?? "")
+    };
+  return {
+    ...metadata,
+    kind: String(part.type),
+    text: typeof part.text === "string" ? part.text : typeof part.thinking === "string" ? part.thinking : undefined
+  };
 }
 
 // src/hooks/magic-context/transform-postprocess-phase.ts
@@ -14012,6 +14630,28 @@ function freezeReasoningOnBustingPass(args) {
   sessionLog(args.sessionId, `proactive thinking strip: busting pass froze reasoning of ${messageIds.length} assistant(s) [${messageIds.join(",")}]`);
   return { strip: { messageIds }, persistenceFailed: false };
 }
+function servesThinkingBlock(messages) {
+  for (const message of messages) {
+    if (message.info.role !== "assistant")
+      continue;
+    for (const part of message.parts) {
+      if (!isRecord(part) || part.ignored === true)
+        continue;
+      if (part.type === "redacted_thinking")
+        return true;
+      if (part.type !== "reasoning" && part.type !== "thinking")
+        continue;
+      const anthropic = isRecord(part.metadata) ? part.metadata.anthropic : undefined;
+      if (!isRecord(anthropic))
+        continue;
+      if (anthropic.redactedData !== undefined)
+        return true;
+      if (typeof part.text === "string" && part.text !== "")
+        return true;
+    }
+  }
+  return false;
+}
 function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
   const tagNumber = getTagNumberByMessageId(db, sessionId, `${summaryMessageId}:p0`);
   if (tagNumber !== null)
@@ -14175,7 +14815,7 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
       clearedParts = stripClearedReasoning(targetedMessages.filter((message) => !restoredMessages.has(message)));
     }
   }
-  const bindingRecoveryParts = options?.skipMergedReasoningStrip ? 0 : stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
+  const bindingRecoveryParts = stripReasoningFromAssistantIds(messages, resolvedProviderID, options?.frozenThinkingBindingMessageIds ?? new Set, restoredMessages);
   const mergedReasoningParts = bindingRecoveryParts + (options?.skipMergedReasoningStrip ? 0 : stripReasoningFromMergedAssistants(messages, resolvedProviderID, {
     mutationExemptMessage: options?.reasoningMutationExemptMessage,
     frozenMessageIds: options?.mergedReasoningStrippedIds,
@@ -14187,6 +14827,25 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
   }
   return { clearedParts, mergedReasoningParts };
 }
+function legacyPublishedHeadChanged(args) {
+  if (!args.pendingCompartmentInjection || !args.readLastServedMessages)
+    return false;
+  const served = args.readLastServedMessages();
+  if (served === null)
+    return true;
+  const previous = served[0];
+  if (!Array.isArray(previous?.parts) || !args.pendingCompartmentInjection)
+    return false;
+  const text = previous.parts.find((part) => typeof part === "object" && part !== null && ("type" in part) && part.type === "text" && ("text" in part))?.text;
+  if (typeof text !== "string")
+    return false;
+  const block = `<session-history>
+${args.pendingCompartmentInjection.block}
+</session-history>`;
+  return text !== block && !text.startsWith(`${block}
+
+`);
+}
 async function runPostTransformPhase(args) {
   const tPostprocessSetup = performance.now();
   const compactionOff = args.compactionOff === true;
@@ -14233,7 +14892,7 @@ async function runPostTransformPhase(args) {
   let deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   let materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
-  const frozenThinking = new Set(args.activeThinkingTurn ? getMergedReasoningStrippedIds(args.db, args.sessionId) : []);
+  const frozenThinking = new Set(getMergedReasoningStrippedIds(args.db, args.sessionId));
   const bindingThinking = new Set([...frozenThinking].filter((id) => id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX)).map((id) => id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length)));
   const retainedThinking = args.activeThinkingTurn ? retainedActiveThinkingParts({
     messages: args.messages,
@@ -14259,6 +14918,7 @@ async function runPostTransformPhase(args) {
   let freezeM0M1 = args.freezeM0M1 === true || activeThinkingPrefixHold;
   let rewritingSignedPrefix = false;
   let thinkingReleasedForFit = false;
+  let thinkingOmissionPersistenceFailed = false;
   const releaseThinkingForRewrite = (forFit = false) => {
     const stripped = freezeReasoningOnBustingPass({
       db: args.db,
@@ -14266,8 +14926,12 @@ async function runPostTransformPhase(args) {
       messages: args.messages,
       alreadyFrozen: bindingThinking
     });
-    if (stripped.persistenceFailed)
+    if (stripped.persistenceFailed) {
+      thinkingOmissionPersistenceFailed = true;
       throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+    }
+    for (const id of stripped.strip?.messageIds ?? [])
+      bindingThinking.add(id);
     retainedThinking.clear();
     protectedThinkingMessages.clear();
     activeThinkingTurn = false;
@@ -14277,6 +14941,9 @@ async function runPostTransformPhase(args) {
     rewritingSignedPrefix = true;
     thinkingReleasedForFit ||= forFit;
   };
+  if (args.compactionModeTransition && args.thinkingBindingRecoveryEnabledForModel) {
+    releaseThinkingForRewrite();
+  }
   const foldDueDecision = m0M1EnabledForFold && args.m0M1 && !freezeM0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -14312,6 +14979,8 @@ async function runPostTransformPhase(args) {
   };
   if ((foldDueDecision.value || softRefreshOpportunity || firstRenderBust && activeThinkingPrefixHold) && m0M1EnabledForFold && args.m0M1) {
     let committedFoldBustsServedPrefix;
+    let committedFoldChangesHead = false;
+    let committedFoldThinkingIds = [];
     try {
       const previousM1 = args.sessionMeta.cachedM1Bytes?.toString("utf8");
       const foldResult = injectM0M1({
@@ -14338,6 +15007,24 @@ async function runPostTransformPhase(args) {
               m0Text: rendered.m0Bytes.toString(),
               m1Text: rendered.m1Bytes.toString()
             }) : foldBustsServedPrefix(foldDueDecision.reason, servedPrefixBeforeFold, rendered);
+            committedFoldChangesHead = firstRenderBust ? !servedPrefixMatches({
+              messages: servedBeforeFirstRender,
+              m0Text: rendered.m0Bytes.toString(),
+              m1Text: rendered.m1Bytes.toString()
+            }) : foldChangesServedPrefix(servedPrefixBeforeFold, rendered);
+            if (args.thinkingBindingRecoveryEnabledForModel && (compactionOff && !activeThinkingPrefixHold && committedFoldChangesHead || activeThinkingPrefixHold && firstRenderBust && bustsPrefix)) {
+              const omission = freezeReasoningOnBustingPass({
+                db,
+                sessionId: args.sessionId,
+                messages: args.messages,
+                alreadyFrozen: bindingThinking
+              });
+              if (omission.persistenceFailed) {
+                thinkingOmissionPersistenceFailed = true;
+                throw new Error("Cannot persist signed thinking omission before prefix rewrite");
+              }
+              committedFoldThinkingIds = omission.strip?.messageIds ?? [];
+            }
             if (bustsPrefix) {
               if (!conversions.isCurrent(db)) {
                 throw new MaterializeContentionError({
@@ -14354,7 +15041,13 @@ async function runPostTransformPhase(args) {
         }
       });
       preparedPrefix = foldResult;
-      if (activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+      if (foldResult.m0RematerializedThisPass) {
+        for (const id of committedFoldThinkingIds)
+          bindingThinking.add(id);
+      }
+      if (foldResult.m0RematerializedThisPass && activeThinkingPrefixHold && firstRenderBust && committedFoldBustsServedPrefix) {
+        releaseThinkingForRewrite();
+      } else if (compactionOff && foldResult.m0RematerializedThisPass && !activeThinkingPrefixHold && args.thinkingBindingRecoveryEnabledForModel && committedFoldChangesHead) {
         releaseThinkingForRewrite();
       }
       prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
@@ -14383,6 +15076,8 @@ async function runPostTransformPhase(args) {
         sessionLog(args.sessionId, "channel2 fold-cycle reset failed (ignored):", error);
       }
     } catch (error) {
+      if (thinkingOmissionPersistenceFailed)
+        throw error;
       preparedPrefix = cachedPrefixBeforePreflight;
       prefixPreflightFailed = true;
       failPass("m0-m1-fold-preexecution-degradation", error);
@@ -14390,11 +15085,6 @@ async function runPostTransformPhase(args) {
     }
     sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${m0MaterializeReason ?? foldDueDecision.reason ?? (foldExecutedThisPass ? "drift" : "soft_refresh")} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
   }
-  if (args.normalizeRecoveryTail && (foldBustsServedPrefixThisPass || firstRenderBust)) {
-    args.normalizeRecoveryTail();
-    args.tags = getTagsBySession(args.db, args.sessionId);
-    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
-  }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();
   const frontToolCandidates = args.tags.filter((tag) => tag.type === "tool" && tag.status === "active" && args.targets.get(tag.tagNumber)?.canDrop?.());
@@ -14421,13 +15111,19 @@ async function runPostTransformPhase(args) {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
-    explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
-    publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
+    explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
+    publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
   };
   const publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
   const shouldRunHeuristics = !compactionOff && publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  if (args.normalizeRecoveryTail && isCacheBustingPass) {
+    args.normalizeRecoveryTail();
+    args.tags = getTagsBySession(args.db, args.sessionId);
+    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  }
+  const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(args.messages, args.targets) : [];
   const canEditWholePrefix = isCacheBustingPass && !activeThinkingPrefixHold;
   const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
     ...args.temporalObservedDecisions ?? [],
@@ -14499,17 +15195,28 @@ async function runPostTransformPhase(args) {
       throw new EmergencyFailClosedError("Magic Context could not read its saved reasoning-removal state for this session", { cause: error });
     }
   }
+  const heuristicsLogChanged = diagnosticStateChanged(args.sessionId, "heuristics", JSON.stringify([
+    args.currentTurnId,
+    shouldRunHeuristics,
+    shouldRunHeuristics ? null : args.schedulerDeferReason
+  ]));
+  const pendingLogChanged = diagnosticStateChanged(args.sessionId, "pending-ops", JSON.stringify([
+    args.currentTurnId,
+    shouldApplyPendingOps,
+    shouldApplyPendingOps ? null : args.schedulerDeferReason,
+    shouldApplyPendingOps ? null : (getPendingOpsCount(args.db, args.sessionId) ?? 0) > 0
+  ]));
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
     const reason = isExplicitFlush ? `pending_materialization origin=${pendingOrigin}` : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : foldBustsServedPrefixThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `${reclaimRideLabel(rideSignals)} subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `${reclaimRideLabel(rideSignals)} (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
-  } else if (args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  } else if (heuristicsLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog(args.sessionId, `heuristics WILL NOT RUN — reason=${args.schedulerDeferReason}`);
   }
   if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
     sessionLog(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
-  if (!shouldApplyPendingOps && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
+  if (!shouldApplyPendingOps && pendingLogChanged && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog(args.sessionId, `pending ops WILL NOT APPLY — reason=${args.schedulerDeferReason} pendingOps=${formatPendingOpsDepth()} context=${args.contextUsage.percentage.toFixed(1)}%`);
   }
   if (hasPendingUserOps && !shouldApplyPendingOps) {
@@ -14570,7 +15277,7 @@ async function runPostTransformPhase(args) {
       pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, new Set([
         ...args.contextUsage.percentage >= 95 ? [] : args.protectedTagIds,
         ...protectedToolTags
-      ]), undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
+      ]), undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction), undefined, args.onPendingDropEligibility);
       if (pendingOpsDidMutate) {
         droppedCount += pendingOps.length;
         for (const pendingOp of pendingOps) {
@@ -14773,6 +15480,7 @@ async function runPostTransformPhase(args) {
           }
         }
         const editReclaim = buildEditSupersessionReclaim({
+          watermark: args.sessionMeta.toolReclaimWatermark ?? 0,
           db: args.db,
           sessionId: args.sessionId,
           targets: newTargets,
@@ -14811,7 +15519,7 @@ async function runPostTransformPhase(args) {
     const tBatchFinalize = performance.now();
     args.batch?.finalize();
     if (toolReclaimApplicationOpportunity) {
-      const maxTagNumber = advanceToolReclaimWatermarkToCurrentMax(args.db, args.sessionId);
+      const maxTagNumber = advanceToolReclaimWatermarkByDistance(args.db, args.sessionId, reclaimDistance, args.usableWindow);
       args.sessionMeta.toolReclaimWatermark = Math.max(args.sessionMeta.toolReclaimWatermark ?? 0, maxTagNumber);
     }
     if (autoReclaimTargetCount > 0) {
@@ -14895,6 +15603,30 @@ async function runPostTransformPhase(args) {
     }
   }
   const m0M1Enabled = m0M1EnabledForFold;
+  let retainCoveredInstructions = false;
+  if (m0M1Enabled && args.m0M1 && !compactionOff && args.hostInstructionRows) {
+    const covered = args.coveredHostInstructions ?? [];
+    if (covered.length > 0 || canEditWholePrefix) {
+      let retain = false;
+      try {
+        retain = isHostInstructionRetentionOn(args.db, args.sessionId);
+      } catch (error) {
+        failPass("host-instruction-retention-read-failure", error);
+      }
+      if (!retain && canEditWholePrefix) {
+        let written = false;
+        try {
+          written = markHostInstructionRetention(args.db, args.sessionId);
+        } catch (error) {
+          failPass("host-instruction-retention-persistence-failure", error);
+        }
+        if (!written)
+          failPass("host-instruction-retention-persistence-failure");
+        retain = true;
+      }
+      retainCoveredInstructions = retain;
+    }
+  }
   if (m0M1Enabled && args.m0M1) {
     if (freezeM0M1 && !preparedPrefix) {
       preparedPrefix = prepareCachedM0M1Replay(args.db, args.sessionId);
@@ -14922,6 +15654,17 @@ async function runPostTransformPhase(args) {
         compactionOff
       });
       deliveredPrefix = result;
+      if (retainCoveredInstructions) {
+        const retained = new Set(args.messages);
+        const covered = [...args.coveredHostInstructions ?? []];
+        for (const message of messagesBeforeInjection) {
+          if (!retained.has(message) && isHostRenderedSystemMessage(message)) {
+            markCoveredInstructionRow(message.info);
+            covered.push(message);
+          }
+        }
+        args.messages.splice(result.prependedMessageCount, 0, ...covered);
+      }
       if (result.prefixTrimStatus === "applied") {
         const retainedMessages = new Set(args.messages);
         const trimmedMessageIds = messagesBeforeInjection.filter((message) => !retainedMessages.has(message)).map((message) => message.info.id).filter((id) => typeof id === "string");
@@ -15192,7 +15935,7 @@ async function runPostTransformPhase(args) {
     }
   }
   const mergedReasoningStrippedIds = new Set(replaySnapshot?.mergedReasoningStrippedIds ?? []);
-  const thinkingBindingRecoveryMessageIds = new Set;
+  const thinkingBindingRecoveryMessageIds = new Set(bindingThinking);
   let thinkingBindingRecovery = null;
   let proactiveThinkingStrip = null;
   if (!compactionOff) {
@@ -15444,6 +16187,7 @@ async function runPostTransformPhase(args) {
         const hygieneCalibration = sessionDecisionCalibration(args.db, args.sessionId);
         const hygieneUnitsVersion = transitionSessionHygieneUnits(args.db, args.sessionId, bustedThisPass, hygieneCalibration);
         const baseline = refreshTailHygieneBaseline({
+          opencode2: args.opencode2,
           messages: args.messages,
           tags,
           protectedTagNumbers: args.protectedTagNumbers,
@@ -15459,7 +16203,7 @@ async function runPostTransformPhase(args) {
           sessionLog(args.sessionId, formatTailHygienePrefixMismatch(baseline.lastPrefixMismatch, baseline.baselineGeneration));
         }
         const tTailState = performance.now();
-        const structuralSignature = tailHygieneStructuralSignature(args.messages);
+        const structuralSignature = tailHygieneStructuralSignature(args.messages, args.opencode2);
         const effective = effectiveTailHygiene(baseline);
         const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(args.db, args.sessionId, effective.u) : getChannel1NudgeState(args.db, args.sessionId);
         baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
@@ -15471,7 +16215,7 @@ async function runPostTransformPhase(args) {
           ...baseline,
           usableWindow: args.usableWindow,
           realUserTurnCount: countRealUserMessages(args.messages),
-          reducedSinceRefresh: baseline.baselineGeneration !== previous?.baselineGeneration ? false : previous?.reducedSinceRefresh ?? false,
+          reducedSinceRefresh: baseline.baselineGeneration !== previous?.baselineGeneration || (previous?.generationInvalidated === true || previous?.evaluable === false) && baseline.evaluable && !baseline.generationInvalidated ? false : previous?.reducedSinceRefresh ?? false,
           agentDropsAppliedThisPass: pendingOpsDidMutate,
           oldestReclaimableToolTags: postprocessOldestTags(args.db, args.sessionId, args.protectedTagNumbers)
         });
@@ -15509,7 +16253,7 @@ async function runPostTransformPhase(args) {
   const tTailGuard = performance.now();
   if (assertedBaseline) {
     try {
-      const servedSignature = tailHygieneStructuralSignature(args.messages);
+      const servedSignature = tailHygieneStructuralSignature(args.messages, args.opencode2);
       if (!sameTailHygieneStructuralSignature(assertedBaseline.structuralSignature, servedSignature)) {
         sessionLog(args.sessionId, `ERROR [tail-hygiene-last-writer-mismatch]: served messages changed after tail-hygiene baseline refresh (expected messages=${assertedBaseline.structuralSignature.messageCount}, parts=[${assertedBaseline.structuralSignature.partCounts.join(",")}], bytes=${assertedBaseline.structuralSignature.totalBytes}; actual messages=${servedSignature.messageCount}, parts=[${servedSignature.partCounts.join(",")}], bytes=${servedSignature.totalBytes})`);
       }
@@ -15517,6 +16261,7 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "ERROR [tail-hygiene-last-writer-check-failed]: structural production guard failed open:", error);
     }
     assertTailHygieneContentUnchangedIfEnabled({
+      opencode2: args.opencode2,
       messages: args.messages,
       tags: assertedBaseline.tags,
       protectedTagNumbers: assertedBaseline.protectedTagNumbers,
@@ -15584,15 +16329,27 @@ class UnmanagedOverWindowError extends Error {
 }
 
 // src/hooks/magic-context/unresolved-history-boundary.ts
+function storedHistoryBoundaryPresence(db, sessionId) {
+  try {
+    const row = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(sessionId);
+    return row?.id ? hasRawSessionMessageById2(sessionId, row.id) : undefined;
+  } catch {
+    return;
+  }
+}
+
 class UnresolvedHistoryBoundaryError extends Error {
   estimatedTokens;
   contextLimitTokens;
+  boundaryPresent;
   code = "UNRESOLVED_HISTORY_BOUNDARY";
   recoverable = true;
-  constructor(estimatedTokens, contextLimitTokens) {
-    super(renderUserFacingFailure("history_boundary_unresolved", "plain"));
+  constructor(estimatedTokens, contextLimitTokens, boundaryPresent) {
+    const reason = boundaryPresent === true ? "The boundary row is present in the host store but out of order relative to the loaded history. " : boundaryPresent === false ? "The boundary row is missing from the host store. " : "";
+    super(reason + renderUserFacingFailure("history_boundary_unresolved", "plain"));
     this.estimatedTokens = estimatedTokens;
     this.contextLimitTokens = contextLimitTokens;
+    this.boundaryPresent = boundaryPresent;
     this.name = "UnresolvedHistoryBoundaryError";
   }
 }
@@ -15676,13 +16433,16 @@ function resolveTransformHostSeams(deps) {
   };
 }
 function createTransform(deps) {
+  const pendingDropEligibility = createPendingDropEligibilityCache();
   registerSystemDateRefresh(deps.historyRefreshSessions);
   const finalWireUsage = createFinalWireUsageTracker();
   const host = resolveTransformHostSeams(deps);
   const loadedSessions = new Set;
   const prefixHoldLogTurnIds = new Map;
   const thinkingFitRetries = new Set;
+  const compactionModeTransitionPending = new Set;
   const clearSessionLogState = (sessionId) => {
+    clearDiagnosticLogState(sessionId);
     prefixHoldLogTurnIds.delete(sessionId);
   };
   const unmanagedOverWindowSessions = new Set;
@@ -15703,7 +16463,8 @@ function createTransform(deps) {
     const startTime = performance.now();
     const historianRun = deps.resolveHistorianRun?.();
     const messages = output.messages;
-    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? structuredClone(messages) : null;
+    const originalForThinkingFit = messages.some((message) => message.parts.some((part) => isRecord(part) && ["reasoning", "thinking", "redacted_thinking"].includes(String(part.type)))) ? cloneKeepingCoveredInstructionMarks(messages) : null;
+    const coveredHostInstructions = takeCoveredInstructionRows(messages);
     const passOutcome = createPassOutcome();
     const tSessionId = performance.now();
     const sessionId = findSessionId(messages);
@@ -15726,7 +16487,7 @@ function createTransform(deps) {
       return historianRun?.toastDurationMs === undefined ? params : { ...params, toastDurationMs: historianRun.toastDurationMs };
     };
     beginLkgPass(sessionId);
-    clearOpenCodePendingTransformDecision(sessionId);
+    clearOpenCodePendingTransformDecision(sessionId, messages);
     const db = deps.db;
     try {
       const tPrepare = performance.now();
@@ -15801,6 +16562,7 @@ function createTransform(deps) {
       const hasTransitionEffects = transition.recordToWrite !== null || transition.notice !== null || transition.invalidatedM0Baseline || transition.clearedCompartmentInProgress || transition.historianCatchUpSignaled;
       if (hasTransitionEffects) {
         if (transition.invalidatedM0Baseline) {
+          compactionModeTransitionPending.add(sessionId);
           sessionMeta = {
             ...sessionMeta,
             cachedM0Bytes: null,
@@ -16080,9 +16842,10 @@ function createTransform(deps) {
     const persistedUsageFreshForBoundary = persistedUsageBeforeResets && Date.now() - persistedUsageBeforeResets.updatedAt <= 10 * 60 * 1000 && (persistedUsageBeforeResets.lastObservedModelKey === null || currentModelKeyForBoundary === undefined || piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) === piModelRefToCanonical(currentModelKeyForBoundary)) && (resolvedContextLimit === undefined || persistedUsageBeforeResets.lastUsageContextLimit === 0 || persistedUsageBeforeResets.lastUsageContextLimit === resolvedContextLimit) ? persistedUsageBeforeResets.usage : null;
     const boundaryUsageForProtectedTail = persistedUsageFreshForBoundary ?? contextUsageEarly;
     const boundaryUsageSource = persistedUsageFreshForBoundary ? "persisted" : "live";
-    const historyPolicyIdentity = historyBudgetPolicyIdentity(deps.historyBudgetPercentage, deps.executeThresholdPercentage, currentModelKeyForBoundary, deps.executeThresholdTokens);
     const historyContextLimit = resolvedContextLimit ?? (currentModelKeyForBoundary && persistedUsageBeforeResets?.lastObservedModelKey && piModelRefToCanonical(currentModelKeyForBoundary) === piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) && persistedUsageBeforeResets.lastUsageContextLimit > 0 ? persistedUsageBeforeResets.lastUsageContextLimit : undefined);
-    const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens, historyContextLimit);
+    const memoryProjectDirectory = compartmentDirectory || process.cwd();
+    const renderOptions = createM0RenderOptions(deps, contextUsageEarly, currentModelKeyForBoundary, historyContextLimit, deps.memoryConfig?.enabled ? resolveProjectIdentityForSession(memoryProjectDirectory, deps.allowHomeProject) : undefined);
+    const { historyBudgetTokens, projectPath: projectIdentity } = renderOptions;
     const emergencyCeilingLimit = thresholdContextLimit ?? 0;
     const emergencyCeilingTokens = Number.isFinite(emergencyCeilingLimit) && emergencyCeilingLimit > 0 ? Math.floor(emergencyCeilingLimit * (effectiveExecuteThresholdPercentage / 100)) : undefined;
     const schedulerDecision = compactionOff ? "defer" : resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId), resolvedContextLimit);
@@ -16215,8 +16978,6 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       });
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
-    const memoryProjectDirectory = compartmentDirectory || process.cwd();
-    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentityForSession(memoryProjectDirectory, deps.allowHomeProject) : undefined;
     if (deps.memoryConfig?.enabled) {
       maybeSendProjectIdentityWarning(deps, sessionId, memoryProjectDirectory, notificationParams);
     }
@@ -16230,13 +16991,26 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       recordedSessionProjectIdentity.set(sessionId, sessionIdentityForBinding);
     }
     const taggerFloor = compactionOff ? 0 : deriveTaggerLoadFloor(messages, sessionId, db);
-    if (!compactionOff && taggerFloor === 0 && messages.length > 0) {
-      sessionLog(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
+    const tagFloorMode = compactionOff || messages.length === 0 ? "inactive" : taggerFloor === 0 ? "fallback" : "scoped";
+    if (diagnosticStateChanged(sessionId, "tag-floor", tagFloorMode) && tagFloorMode !== "inactive") {
+      sessionLog(sessionId, taggerFloor === 0 ? `tag floor: 0 (full-scan fallback) — no scoped floor above the safety margin across ${messages.length} msgs` : `tag floor: ${taggerFloor} (scoped load)`);
     }
     const ownerRatio = sessionDecisionCalibration(db, sessionId).proseRatio;
     prewarmTagOwners(db, sessionId, ownerRatio);
     const tagOwnersReady = isTagOwnerSummaryReady(db, sessionId, ownerRatio);
     let triggerBoundarySnapshot;
+    const dropProjectionEmergency = contextUsageEarly.percentage >= 95;
+    const dropProjectionKey = () => pendingDropEligibilityKey(db, sessionId, lkgInput, {
+      currentTurnId,
+      model: modelForBudget,
+      protectedTokens: deps.protectedTokens,
+      protectedTokenTierOverrides: deps.protectedTokenTierOverrides,
+      protectedTools: deps.protectedTools,
+      keepReasoningTokens: deps.keepReasoningTokens,
+      usableSoft: windowGeometry?.usableSoft ?? boundaryContextLimit,
+      emergency: dropProjectionEmergency,
+      clearedReasoningThroughTag: sessionMeta?.clearedReasoningThroughTag
+    });
     if (fullFeatureMode && !compactionOff && historianRunnable && tagOwnersReady && !sessionMeta.compartmentInProgress) {
       const tTrigger = performance.now();
       try {
@@ -16249,7 +17023,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           force: contextUsageEarly.percentage >= forceMaterializationPercentage && (contextUsageEarly.percentage >= 95 || getEmergencyInputSample(db, sessionId) === 0),
           explicitFlush: deps.pendingMaterializationSessions.has(sessionId),
           publishedHistory: isCacheBusting
-        });
+        }, pendingDropEligibility.read(sessionId, dropProjectionKey()));
         if (triggerResult.shouldFire) {
           sessionLog(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
           updateSessionMeta(db, sessionId, { compartmentInProgress: true });
@@ -16257,8 +17031,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           triggerBoundarySnapshot = triggerResult.boundarySnapshot;
         }
       } catch (error) {
-        passOutcome.record("compartment-trigger-failure");
-        sessionLog(sessionId, "compartment trigger failed (non-fatal):", error);
+        recordCompartmentTriggerError(passOutcome, sessionId, error);
       }
       logTransformTiming(sessionId, "compartmentTrigger", tTrigger);
     }
@@ -16269,7 +17042,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const messagesBeforeInitialPrepare = isCacheBusting && deferredHistoryWasPendingAtPassStart ? [...messages] : null;
     if (fullFeatureMode && !compactionOff) {
       const tInj = performance.now();
-      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
+      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness, coveredHostInstructions);
       if (messagesBeforeInitialPrepare) {
         const skippedVisibleMessages = pendingCompartmentInjection?.skippedVisibleMessages ?? 0;
         trimmedMessagesAtCompactionBoundary = messagesBeforeInitialPrepare.slice(0, skippedVisibleMessages);
@@ -16299,6 +17072,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       logTransformTiming(sessionId, "injectTemporalMarkers", tTemporal);
     }
     let taggingSucceeded = false;
+    const refreshSourceContents = deps.storeGeneration === "v2" && fullFeatureMode && !compactionOff && !!(projectIdentity || sessionDirectory) && !unresolvedDirectoryHold && !recovery.prefix && sessionMeta.cachedM0Bytes == null && sessionMeta.cachedM1Bytes == null && deps.refreshSourceContents?.(sessionId) === true;
     let recoveryBatch = null;
     let recoveryNormalized = false;
     const normalizeRecoveryTail = recovery.prefix ? () => {
@@ -16334,7 +17108,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           scopedToolSweep,
           servedMessages: messages,
           protectedThinkingMessages: protectedThinkingMessagesForPass,
-          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText
+          normalizeRestoredAssistantText: deps.normalizeRestoredAssistantText,
+          refreshSourceContents
         });
         targets = result.targets;
         if (thinkingRecovery.restore)
@@ -16415,6 +17190,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const rawGetNotifParams = runNotificationParams;
     const tCompartmentPhase = performance.now();
     const compartmentPhase = await runCompartmentPhase({
+      coveredHostInstructions,
       hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
       compactionMarkerStrategy: deps.compactionMarkerStrategy,
       canRunCompartments,
@@ -16498,12 +17274,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       db,
       sessionId,
       state: sessionMeta,
-      projectPath: projectIdentity,
       projectDirectory: sessionDirectory,
-      memoryEnabled: deps.memoryConfig?.enabled,
-      memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
-      historyBudgetTokens,
-      historyBudgetPolicyIdentity: historyPolicyIdentity,
+      ...renderOptions,
       hardSignals: m0HardSignals
     }).value;
     const protectionCacheBustingPass = !compactionOff && (schedulerDecision === "execute" || isCacheBusting || contextUsage.percentage >= forceMaterializationPercentage || deps.pendingMaterializationSessions.has(sessionId) || canConsumeDeferredLate && deferredMaterializationSessions.has(sessionId) || protectionFoldWillBust);
@@ -16585,6 +17357,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       fullFeatureMode,
       compactionOff,
       canRunCompartments,
+      hostInstructionRows: deps.storeGeneration === "v2",
       awaitedCompartmentRun,
       phaseJustAwaitedPublication: compartmentPhase.justAwaitedPublication,
       compartmentInProgress,
@@ -16593,6 +17366,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       activeThinkingPrefixHold,
       directoryPrefixHold: unresolvedDirectoryHold,
       forceSignedRebuildForFit: thinkingFitRetries.has(sessionId) || !!recovery.rebuildReason,
+      compactionModeTransition: compactionModeTransitionPending.has(sessionId),
       readLastServedMessages: () => {
         const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
         try {
@@ -16615,12 +17389,14 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       keepReasoningTokens: resolveKeepReasoningTokens(deps.keepReasoningTokens, currentModelKeyForBoundary),
       resolvedModelID: modelForBudget?.modelID,
       protectedTagIds,
+      onPendingDropEligibility: (eligible) => pendingDropEligibility.record(sessionId, dropProjectionKey(), eligible),
       protectedTagNumbers,
       protectedCutoff,
       protectedCount: protectionWindow.status.protectedCount,
       emergencyCeilingTokens,
       pendingCompartmentInjection,
       prefixTrimSourceOrder,
+      coveredHostInstructions,
       hiddenMessagesAtCompactionSeam,
       trimmedMessagesAtCompactionBoundary,
       didMutateFromFlushedStatuses,
@@ -16642,13 +17418,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       passOutcome,
       historyRefreshSessions: deps.historyRefreshSessions,
       m0M1: {
-        projectPath: projectIdentity,
         projectDirectory: sessionDirectory,
-        memoryEnabled: deps.memoryConfig?.enabled,
-        memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
-        historyBudgetTokens,
-        historyBudgetPolicyIdentity: historyPolicyIdentity,
-        temporalAwareness: deps.experimentalTemporalAwareness,
+        ...renderOptions,
         hardSignals: m0HardSignals
       }
     });
@@ -16716,7 +17487,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         });
         if (untrimmed.tokens > boundaryContextLimit) {
           sessionLog(sessionId, `history boundary unresolved: prefix trim refused and the untrimmed request estimate ${untrimmed.tokens} (trusted=${untrimmed.trusted}) exceeds the context limit ${boundaryContextLimit}; not sending it`);
-          throw new UnresolvedHistoryBoundaryError(untrimmed.tokens, boundaryContextLimit);
+          throw new UnresolvedHistoryBoundaryError(untrimmed.tokens, boundaryContextLimit, storedHistoryBoundaryPresence(db, sessionId));
         }
       }
       if (unmanagedOverWindowPass) {
@@ -16820,7 +17591,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (!finalWireEstimate) {
       sessionLog(sessionId, `transform: final-wire telemetry estimate=unavailable trusted=false conversation=unknown tools=unknown system=unknown toolDefinitions=unknown tail=${finalWireTail}`);
     }
-    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold || postTransformResult.thinkingReleasedForFit === true);
+    const signedThinkingServed = isPrefixBoundThinkingModel(modelForBudget?.providerID, modelForBudget?.modelID) && servesThinkingBlock(messages);
+    finishSystemDateRefresh(deps.historyRefreshSessions, dateRequest, postTransformResult.bustedThisPass && !activeThinkingPrefixHold && !signedThinkingServed || postTransformResult.thinkingReleasedForFit === true, signedThinkingServed);
+    compactionModeTransitionPending.delete(sessionId);
     if (activeThinkingPrefixHold && !postTransformResult.thinkingReleasedForFit && sessionMeta.cachedM0Bytes != null && sessionMeta.cachedM1Bytes != null) {
       recordHeldHeadForRequest(sessionId, currentLkgRequestIdentity(sessionId), (ownsHistory) => deferDeliveredSystemRefresh(deps, sessionId, ownsHistory));
     }
@@ -16893,6 +17666,24 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         bustedThisPass: true,
         lkgFrozenReleaseReason: recoveryReleaseReason
       });
+    } else {
+      noteOpenCodeUnbustedPass(sessionId, {
+        tsMs: Date.now(),
+        decision: schedulerDecision,
+        materialized: postTransformResult.materialized,
+        materializeReason: normalizeMaterializeReason("opencode", postTransformResult.materializeReason, postTransformResult.materialized),
+        systemHashPrev: postTransformResult.systemHashPrev,
+        systemHashNew: postTransformResult.systemHashNew,
+        m0ToolSetHashPrev: postTransformResult.m0ToolSetHashPrev,
+        m0ToolSetHashNew: postTransformResult.m0ToolSetHashNew,
+        m0ModelKeyPrev: postTransformResult.m0ModelKeyPrev,
+        m0ModelKeyNew: postTransformResult.m0ModelKeyNew,
+        emergency: postTransformResult.emergency,
+        droppedTokens: postTransformResult.droppedTokens,
+        droppedCount: postTransformResult.droppedCount,
+        inputTokens: contextUsage.inputTokens,
+        bustedThisPass: false
+      });
     }
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
     const msgTokens = getMessageTokensCache(sessionId);
@@ -16904,6 +17695,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     if (uncachedMessageIds.length > 0) {
       try {
         storedByMessage = getActiveTagTokenTotalsByMessage(db, sessionId, uncachedMessageIds);
+        omitIncompleteFileTokenTotals(db, sessionId, messages.flatMap((message) => typeof message.info.id === "string" ? [{ id: message.info.id, parts: message.parts }] : []), storedByMessage);
       } catch {
         storedByMessage = new Map;
       }
@@ -16960,7 +17752,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           postReduceGraceBaselineU: channel1State.postReduceGraceBaselineU,
           postReduceGracePreLevel: channel1State.postReduceGracePreLevel
         });
-        sessionLog(sessionId, formatChannel1Evaluation(channel1Decision));
+        logNudgeEvaluation(sessionId, "transform", formatChannel1Evaluation(channel1Decision));
         const channel2Evaluation = evaluateChannel2(channelBaseline);
         const leaseBefore = getChannel2NudgeState(db, sessionId);
         if (channelBaseline.evaluable && !channelBaseline.generationInvalidated && !channelBaseline.reducedSinceRefresh) {
@@ -16971,7 +17763,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           }
         }
         const leaseAfter = getChannel2NudgeState(db, sessionId);
-        sessionLog(sessionId, formatChannel2Evaluation(channel2Evaluation, {
+        logNudgeEvaluation(sessionId, "transform", formatChannel2Evaluation(channel2Evaluation, {
           leaseBefore,
           leaseAfter,
           gateHoldReason: channelBaseline.reducedSinceRefresh ? "recent-reduce-refresh" : undefined
@@ -17010,7 +17802,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       sessionLog(sessionId, "memory maintenance launch probe failed (ignored):", error);
     }
   };
-  return Object.assign(transform, {
+  const timedTransform = (input, output) => withTransformTimingSummary(() => transform(input, output));
+  return Object.assign(timedTransform, {
     clearSessionLogState(sessionId) {
       clearSessionLogState(sessionId);
     }
@@ -17047,11 +17840,19 @@ function clearMaintenanceSystemSnapshot(sessionId) {
 function readMaintenanceSystemSnapshot(sessionId) {
   return maintenanceSystemSnapshotBySession.get(sessionId);
 }
+var maintenanceModelUnconfiguredNoted = new Set;
+function noteMaintenanceModelUnconfigured(projectPath, sessionId) {
+  if (maintenanceModelUnconfiguredNoted.has(projectPath))
+    return;
+  maintenanceModelUnconfiguredNoted.add(projectPath);
+  sessionLog(sessionId, "memory maintenance skipped: neither maintenance.model nor historian.model is configured (set either in the user-level mmc config; the session model is never inherited)");
+}
 function createMaintenanceTailLauncher(deps) {
   const buildLauncher = (projectPath) => (deps.launcherFactory ?? ((db, path) => getMaintenanceLauncher(db, path, {
     getConfig: () => ({
       maintenance: {
-        enabled: deps.getMaintenanceConfig?.()?.enabled ?? false
+        enabled: deps.getMaintenanceConfig?.()?.enabled ?? false,
+        model: deps.getMaintenanceConfig?.()?.model
       }
     }),
     runFactory: (signals) => {
@@ -17089,6 +17890,10 @@ function createMaintenanceTailLauncher(deps) {
           return;
         if (!deps.hiddenCompletionExecutor)
           return;
+        if (!hasMaintenancePrimary(maintenance)) {
+          noteMaintenanceModelUnconfigured(projectPath, input.sessionId);
+          return;
+        }
         const poolCount = countMaintenancePool(deps.db, projectPath);
         const hostSystemText = readMaintenanceSystemSnapshot(input.sessionId);
         buildLauncher(projectPath).maybeLaunch({
@@ -17102,29 +17907,10 @@ function createMaintenanceTailLauncher(deps) {
           ...hostSystemText === undefined ? {} : { hostSystemText }
         });
       } catch (error) {
-        sessionLog(input.sessionId, "memory maintenance probe failed (ignored):", error);
-      }
-    }
-  };
-}
-function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
-  if (!historyBudgetPercentage) {
-    return;
-  }
-  let contextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
-  if (contextLimit <= 0) {
-    if (contextUsage.percentage <= 0) {
-      return;
+        sessionLog(input.sessionId, "memory maintenance probe failed (ignored):", error);
+      }
     }
-    contextLimit = contextUsage.inputTokens / (contextUsage.percentage / 100);
-  }
-  if (!Number.isFinite(contextLimit) || contextLimit <= 0) {
-    return;
-  }
-  return Math.floor(contextLimit * (resolveExecuteThreshold(executeThresholdPercentage ?? 65, modelKey, 65, {
-    tokensConfig: executeThresholdTokens,
-    contextLimit
-  }) / 100) * historyBudgetPercentage);
+  };
 }
 
 // src/plugin/rpc-handlers.ts
@@ -17376,6 +18162,7 @@ function runManualMaintenanceCommand(args) {
   }
   const explanations = {
     "maintenance-disabled": "memory maintenance is disabled (maintenance.enabled: false)",
+    "maintenance-model-unconfigured": "memory maintenance has no primary model configured — set maintenance.model in the user-level mmc config (fallback_models alone does not enable maintenance; the chain never inherits the historian or session model)",
     "run-in-flight-local": "a maintenance run is already in flight; next_due_at is due now, so the launcher retries on the next pass",
     "empty-pool": "memory pool is empty (no active/permanent rows) — nothing to maintain"
   };
@@ -18261,7 +19048,7 @@ function registerRpcHandlers(rpcServer, args) {
   });
   const buildManagedCtx = async (db) => {
     const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-s1p37t2g.js");
-    const { resolveHistorianModel } = await import("./model-resolution-wazv26n0.js");
+    const { resolveHistorianModel } = await import("./model-resolution-cvyrrcjw.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 600000;
     const runConfig = historianRunConfig(config, currentPluginConfigReader(directory)?.poll().effective ?? config);
     const historianModel = resolveHistorianModel(runConfig, "opencode");
@@ -18290,8 +19077,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-wrjy3qym.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-cz6ev088.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-mmpy5cb7.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-zpqs213d.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -18340,7 +19127,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await import("./wrapup-orchestrator-bmybc5p5.js");
+    const { runManagedWrapup } = await import("./wrapup-orchestrator-jq589pgr.js");
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -18372,11 +19159,14 @@ function registerRpcHandlers(rpcServer, args) {
     const raw = String(params.subcommand ?? "status").toLowerCase();
     const action = raw === "run" || raw === "resume" ? raw : "status";
     if (action === "run") {
-      const maintenance = config.maintenance;
+      const maintenance = inheritMaintenanceModelConfig(config);
       const hostSystemText = readMaintenanceSystemSnapshot(sessionId);
       const launcher = getMaintenanceLauncher(db, projectPath, {
         getConfig: () => ({
-          maintenance: { enabled: maintenance?.enabled ?? false }
+          maintenance: {
+            enabled: maintenance?.enabled ?? false,
+            model: maintenance?.model
+          }
         }),
         nowMs: Date.now,
         runFactory: createOc2MaintenanceRunFactory({
@@ -18384,7 +19174,7 @@ function registerRpcHandlers(rpcServer, args) {
           projectPath,
           executor: args.hiddenCompletionExecutor,
           config: () => {
-            const slice = config.maintenance;
+            const slice = inheritMaintenanceModelConfig(config);
             if (!slice) {
               throw new Error("memory maintenance config unavailable");
             }
@@ -18425,8 +19215,17 @@ function subagentToolRefusal(db, toolId, sessionId, isInternalChild = () => fals
 function hideSubagentTools(draft, db) {
   if (!getOrCreateSessionMeta(db, draft.sessionID).isSubagent)
     return;
+  removePrimaryOnlyTools(draft.tools);
+}
+function removePrimaryOnlyTools(tools) {
   for (const id of PRIMARY_ONLY_TOOLS)
-    delete draft.tools[id];
+    delete tools[id];
+}
+function storedSubagentMode(db, sessionId) {
+  const row = db.prepare("SELECT is_subagent FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!row || typeof row.is_subagent !== "number")
+    return;
+  return row.is_subagent === 1;
 }
 
 // src/shared/conflict-detector.ts
@@ -18684,7 +19483,58 @@ function readOmoDisabledHooks(directory) {
 
 // src/shared/rpc-server.ts
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { readdirSync, readFileSync as readFileSync6, unlinkSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync6, rmdirSync, unlinkSync } from "node:fs";
+
+// src/shared/rpc-discovery-cleanup.ts
+import { promises as fs } from "node:fs";
+import { join as join4 } from "node:path";
+async function reapDeadRpcDiscovery(storageDir) {
+  const root = join4(storageDir, "rpc");
+  let directories;
+  try {
+    directories = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const records = [];
+  const projectDirs = [];
+  for (const entry of directories) {
+    if (!entry.isDirectory() || !/^[0-9a-f]{16}$/.test(entry.name))
+      continue;
+    const directory = join4(root, entry.name);
+    projectDirs.push(directory);
+    try {
+      for (const name of await fs.readdir(directory)) {
+        const match = /^port-(\d+)(?:-[0-9a-f]+)?\.json$/.exec(name);
+        if (!match)
+          continue;
+        const path = join4(directory, name);
+        try {
+          const content = await fs.readFile(path, "utf8");
+          const record = parseRpcPortFile(content, Number(match[1]));
+          if (record && record.pid === Number(match[1]))
+            records.push({ path, content, pid: record.pid });
+        } catch {}
+      }
+    } catch {}
+  }
+  const processes = records.length ? await inspectProcessesAsync(true) : undefined;
+  for (const record of records) {
+    if (processes?.liveness(record.pid) !== "dead")
+      continue;
+    try {
+      if (await fs.readFile(record.path, "utf8") === record.content)
+        await fs.unlink(record.path);
+    } catch {}
+  }
+  for (const directory of projectDirs) {
+    try {
+      await fs.rmdir(directory);
+    } catch {}
+  }
+}
+
+// src/shared/rpc-server.ts
 var MAX_BODY_BYTES = 1048576;
 var WS_AUTH_TIMEOUT_MS = 5000;
 var WS_CLOSE_UNAUTHORIZED = 4401;
@@ -18707,17 +19557,20 @@ function websocketToken(req) {
 }
 
 class MagicContextRpcServer {
+  storageDir;
   server = null;
   port = 0;
   handlers = new Map;
   portFilePath;
   portDir;
   startedAt = Date.now();
+  stopped = false;
   instanceId = randomBytes(8).toString("hex");
   unregisterOwnInstance = null;
   sockets = new Set;
   token = randomBytes(32).toString("hex");
   constructor(storageDir, directory) {
+    this.storageDir = storageDir;
     this.portFilePath = rpcPortFilePath(storageDir, directory, process.pid, this.instanceId);
     this.portDir = rpcPortDir(storageDir, directory);
   }
@@ -18735,6 +19588,10 @@ class MagicContextRpcServer {
       log("rpc server skipped: Bun runtime not available (no TUI consumer)");
       return 0;
     }
+    this.stopped = false;
+    await reapDeadRpcDiscovery(this.storageDir);
+    if (this.stopped)
+      return 0;
     this.startedAt = Date.now();
     const self = this;
     const server = Bun.serve({
@@ -18766,7 +19623,7 @@ class MagicContextRpcServer {
     try {
       this.warnIfOtherLiveInstance();
       this.unregisterOwnInstance ??= registerOwnRpcServerInstance(this.instanceId);
-      writeStorageFileAtomicSync(this.portFilePath, JSON.stringify({
+      const publish = () => writeStorageFileAtomicSync(this.portFilePath, JSON.stringify({
         port: this.port,
         pid: process.pid,
         started_at: this.startedAt,
@@ -18774,6 +19631,13 @@ class MagicContextRpcServer {
         token: this.token,
         instance_id: this.instanceId
       }));
+      try {
+        publish();
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+        publish();
+      }
       log(`[rpc] server listening on 127.0.0.1:${this.port}`);
     } catch (err) {
       log(`[rpc] failed to write port file: ${err}`);
@@ -18781,6 +19645,7 @@ class MagicContextRpcServer {
     return this.port;
   }
   stop() {
+    this.stopped = true;
     for (const ws of this.sockets) {
       try {
         if (ws.data.authTimer)
@@ -18797,6 +19662,9 @@ class MagicContextRpcServer {
     try {
       unlinkSync(this.portFilePath);
     } catch {}
+    try {
+      rmdirSync(this.portDir);
+    } catch {}
     this.unregisterOwnInstance?.();
     this.unregisterOwnInstance = null;
   }
@@ -19153,8 +20021,8 @@ var v2CompactionMarkerStrategy = {
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/v2/fold/owner.ts
-import { createHash as createHash4 } from "node:crypto";
-var foldDigest = (value) => createHash4("sha256").update(value).digest("hex");
+import { createHash as createHash3 } from "node:crypto";
+var foldDigest = (value) => createHash3("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -19530,18 +20398,56 @@ function containsHostInstance(value) {
   return false;
 }
 function clonePreservingInstances(value) {
-  if (isHostInstance(value))
+  return cloneCounting(value, undefined);
+}
+function clonePreservingInstancesMeasured(value) {
+  const meter = { bytes: 0 };
+  const copy = cloneCounting(value, meter);
+  return { copy, bytes: meter.bytes };
+}
+function cloneCounting(value, meter) {
+  if (isHostInstance(value)) {
+    if (meter)
+      meter.bytes += instanceBytes(value, new WeakSet);
     return value;
-  if (Array.isArray(value))
-    return value.map(clonePreservingInstances);
+  }
+  if (Array.isArray(value)) {
+    if (meter)
+      meter.bytes += 16 + 8 * value.length;
+    return value.map((entry) => cloneCounting(entry, meter));
+  }
   if (value && typeof value === "object") {
     const copy = {};
-    for (const [key, entry] of Object.entries(value))
-      copy[key] = clonePreservingInstances(entry);
+    if (meter)
+      meter.bytes += 32;
+    for (const [key, entry] of Object.entries(value)) {
+      if (meter)
+        meter.bytes += 16;
+      copy[key] = cloneCounting(entry, meter);
+    }
     return copy;
   }
+  if (meter)
+    meter.bytes += typeof value === "string" ? 2 * value.length : 8;
   return value;
 }
+function instanceBytes(value, seen) {
+  if (typeof value === "string")
+    return 2 * value.length;
+  if (!value || typeof value !== "object")
+    return 8;
+  if (seen.has(value))
+    return 0;
+  seen.add(value);
+  if (ArrayBuffer.isView(value))
+    return value.byteLength;
+  if (value instanceof ArrayBuffer)
+    return value.byteLength;
+  let bytes = 32;
+  for (const entry of Object.values(value))
+    bytes += 16 + instanceBytes(entry, seen);
+  return bytes;
+}
 function contentKey(value) {
   const plain = (entry) => {
     if (ArrayBuffer.isView(entry)) {
@@ -19597,7 +20503,7 @@ function rebuildFileContent(value, output, attachments) {
     rebuilt.unshift({ type: "text", text: output });
   return { type: "content", value: rebuilt };
 }
-function adaptPayload(draft, admittedIDs = new Set) {
+function adaptPayload(draft, admittedIDs = new Set, messageTimes = new Map, hiddenTimes = false) {
   const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
   const source = draft.messages.filter((m) => !existingHeads.has(m.id));
   const results = new Map;
@@ -19707,6 +20613,7 @@ function adaptPayload(draft, admittedIDs = new Set) {
         id: message.id,
         sessionID: draft.sessionID,
         role: message.role,
+        time: message.id ? messageTimes.get(message.id) : undefined,
         ...{
           providerID: draft.model.providerID,
           modelID: draft.model.id,
@@ -19715,7 +20622,19 @@ function adaptPayload(draft, admittedIDs = new Set) {
       },
       parts
     };
+    if (hiddenTimes && mapped.info.time !== undefined) {
+      const time = mapped.info.time;
+      delete mapped.info.time;
+      Object.defineProperty(mapped.info, "time", {
+        value: time,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    }
     originals.set(mapped, message);
+    if (isCoveredInstructionRow(message))
+      markCoveredInstructionRow(mapped.info);
     if (typeof message.id !== "string")
       bridgesByCarrier.set(mapped, byCallID);
     messages.push(mapped);
@@ -20072,24 +20991,31 @@ ${data.output?.output ?? ""}`
   const sameModel = sameProvider && previousModel?.id === model.id;
   const reuse = sameModel && data.error === undefined;
   const metadata = (state) => state === undefined ? undefined : { [model.providerID]: state };
+  const reasoningInterrupted = data.content?.some((part) => part.type === "reasoning" && part.time !== undefined && part.time.completed === undefined);
   const content = [];
   const results = [];
   for (const part of data.content ?? []) {
+    let native = "native" in part ? part.native : part.type === "tool" ? part.providerState : part.state;
+    if (part.type === "tool" && part.providerResultState !== null && typeof part.providerResultState === "object" && !Array.isArray(part.providerResultState))
+      native = {
+        ...native !== null && typeof native === "object" && !Array.isArray(native) ? native : {},
+        ...part.providerResultState
+      };
     if (part.type === "text") {
       if (part.text !== "")
         content.push({
           type: "text",
           text: part.text,
-          providerMetadata: reuse ? metadata(part.state) : undefined
+          providerMetadata: reuse ? metadata(native) : undefined
         });
       continue;
     }
     if (part.type === "reasoning") {
-      if (part.text !== "" || reuse && part.state !== undefined)
+      if (part.text !== "" || reuse && !reasoningInterrupted && native !== undefined)
         content.push({
-          type: reuse || data.error === undefined ? "reasoning" : "text",
+          type: data.error === undefined && !reasoningInterrupted ? "reasoning" : "text",
           text: part.text,
-          providerMetadata: reuse ? metadata(part.state) : undefined
+          providerMetadata: reuse && !reasoningInterrupted ? metadata(native) : undefined
         });
       continue;
     }
@@ -20108,7 +21034,7 @@ ${data.output?.output ?? ""}`
       name: part.name,
       input,
       providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
+      providerMetadata: toolReuse ? metadata(native) : undefined
     });
     if (!completed)
       continue;
@@ -20119,7 +21045,7 @@ ${data.output?.output ?? ""}`
       id: part.id,
       name: part.name,
       providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : undefined,
+      providerMetadata: (part.executed === true ? sameProvider : reuse) ? metadata(native) : undefined,
       result: state.status === "error" ? { error: state.error, content: toolContent } : single?.type === "text" ? { type: "text", value: single.text } : { type: "content", value: toolContent },
       ...state.status === "error" ? { resultType: "error" } : {}
     };
@@ -20147,13 +21073,50 @@ function copyNativeInput(messages) {
   return copies;
 }
 function isLocalCheckpoint(row) {
-  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined;
+  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined && row.data.native?.messages === undefined;
+}
+function isAdmittedLocalCheckpoint(storage, sessionID, cut) {
+  if (!isLocalCheckpoint(cut) || cut.session_id !== sessionID)
+    return false;
+  const admission = storage.admission(sessionID, cut.id);
+  if (!admission?.payload || admission.digest !== foldDigest(admission.payload))
+    return false;
+  try {
+    const snapshot = JSON.parse(admission.payload);
+    return snapshot.source === storage.sourceID && snapshot.sessionID === sessionID && snapshot.admissionID === cut.id && snapshot.summary === cut.data.summary;
+  } catch {
+    return false;
+  }
 }
 var conversational = (row) => RAW_MESSAGE_TYPES.includes(row.type) || row.type === "location-switched";
+var historyDigest = (reader, sessionID, through) => foldDigest(JSON.stringify(reader.range(sessionID, -1, through).filter(conversational)));
+var admissionKey = (sessionID) => `native-fold/v2/${encodeURIComponent(sessionID)}`;
+async function forgetNativeFoldProvenance(storage, sessionID, legacyOnly = false) {
+  const remove = async (key) => {
+    if (storage.remove)
+      await storage.remove(key);
+    else
+      await storage.set(key, null);
+  };
+  if (!legacyOnly)
+    await remove(admissionKey(sessionID));
+  if (!storage.scan)
+    return;
+  let after;
+  do {
+    const page = await storage.scan({ prefix: "native-fold/v1/", after, limit: 100 });
+    for (const { key } of page.entries) {
+      if (key.slice("native-fold/v1/".length).split("/").slice(1).join("/") === sessionID)
+        await remove(key);
+    }
+    after = page.next;
+  } while (after);
+}
 
 class NativeFoldReplay {
   storage;
   openReader;
+  admissions;
   changed = new Set;
   dirty = new Set;
   unavailable = new Set;
@@ -20161,9 +21124,11 @@ class NativeFoldReplay {
   metadataThrough = new Map;
   loaded = new Map;
   sources = new Map;
-  constructor(storage, openReader) {
+  staleHeads = new Set;
+  constructor(storage, openReader, admissions) {
     this.storage = storage;
     this.openReader = openReader;
+    this.admissions = admissions;
     storage.onEvict((sessionID) => this.clear(sessionID));
   }
   account(sessionID) {
@@ -20202,6 +21167,51 @@ class NativeFoldReplay {
   async baseline(sessionID) {
     return this.tail(sessionID)?.baseline;
   }
+  admissionKey(sessionID) {
+    return admissionKey(sessionID);
+  }
+  async removeAdmission(key) {
+    if (this.admissions?.remove)
+      await this.admissions.remove(key);
+    else
+      await this.admissions?.set(key, null);
+  }
+  async removeLegacyAdmissions(sessionID) {
+    if (this.admissions)
+      await forgetNativeFoldProvenance(this.admissions, sessionID, true);
+  }
+  async admits(sessionID, cut, reader) {
+    if (!isLocalCheckpoint(cut) || cut.session_id !== sessionID)
+      return false;
+    if (isAdmittedLocalCheckpoint(this.storage, sessionID, cut))
+      return true;
+    if (!this.admissions)
+      return false;
+    try {
+      const source = reader.hostIdentity();
+      const saved = await this.admissions.get(this.admissionKey(sessionID));
+      if (!saved?.payload || saved.digest !== foldDigest(saved.payload))
+        return false;
+      const snapshot = JSON.parse(saved.payload);
+      if (snapshot.sourceDigest !== foldDigest(source) || snapshot.sessionID !== sessionID || snapshot.admissionID !== cut.id || snapshot.summaryDigest !== foldDigest(cut.data.summary ?? ""))
+        return false;
+      if (snapshot.historyDigest !== historyDigest(reader, sessionID, cut.seq - 1)) {
+        this.staleHeads.add(sessionID);
+        this.invalidate(sessionID);
+        await this.removeAdmission(this.admissionKey(sessionID));
+        return false;
+      }
+      await this.storage.supply(sessionID, cut.id, JSON.stringify({
+        source: this.storage.sourceID,
+        sessionID,
+        admissionID: cut.id,
+        summary: cut.data.summary
+      }));
+      return true;
+    } catch {
+      return false;
+    }
+  }
   rendered(row, model) {
     return restoreRow(row, model, hostUsesMediaAssets() ? {
       asset: hostMediaAsset,
@@ -20279,6 +21289,7 @@ class NativeFoldReplay {
         this.loaded.set(draft.sessionID, through);
         this.unavailable.delete(draft.sessionID);
         this.changed.delete(draft.sessionID);
+        this.staleHeads.delete(draft.sessionID);
       } finally {
         reader.close();
       }
@@ -20305,7 +21316,8 @@ class NativeFoldReplay {
   async supplyHeld(args) {
     const { draft, reader, summary } = args;
     const tail = this.tail(draft.sessionID);
-    const id = reader.latestRunningCompaction(draft.sessionID)?.id;
+    const running = reader.latestRunningCompaction(draft.sessionID);
+    const id = running?.id;
     if (!id || !tail || tail.model !== `${draft.model.providerID}/${draft.model.id}`)
       return false;
     const through = reader.latestSequence(draft.sessionID);
@@ -20329,6 +21341,21 @@ class NativeFoldReplay {
       summary
     };
     await this.storage.supply(draft.sessionID, id, JSON.stringify(snapshot));
+    if (this.admissions) {
+      const provenance = {
+        sourceDigest: foldDigest(reader.hostIdentity()),
+        sessionID: draft.sessionID,
+        admissionID: id,
+        summaryDigest: foldDigest(summary),
+        historyDigest: historyDigest(reader, draft.sessionID, (running?.seq ?? through) - 1)
+      };
+      const payload = JSON.stringify(provenance);
+      await this.admissions.set(this.admissionKey(draft.sessionID), {
+        payload,
+        digest: foldDigest(payload)
+      });
+      await this.removeLegacyAdmissions(draft.sessionID);
+    }
     return true;
   }
   async restore(sessionID, cut, model, options = {}) {
@@ -20413,6 +21440,9 @@ class NativeFoldReplay {
   sourceChanged(sessionID) {
     return this.changed.has(sessionID);
   }
+  needsHeadRebuild(sessionID) {
+    return this.staleHeads.has(sessionID);
+  }
   clear(sessionID) {
     this.sources.delete(sessionID);
     this.metadata.delete(sessionID);
@@ -20421,8 +21451,11 @@ class NativeFoldReplay {
     this.unavailable.delete(sessionID);
     this.dirty.delete(sessionID);
     this.changed.delete(sessionID);
+    this.staleHeads.delete(sessionID);
   }
   async forget(sessionID) {
+    if (this.admissions)
+      await forgetNativeFoldProvenance(this.admissions, sessionID);
     await this.storage.forget(sessionID);
   }
 }
@@ -20437,11 +21470,7 @@ class HostFoldPolicy {
     this.deps = deps;
   }
   owned(sessionID, cut, id) {
-    const row = this.deps.storage.admission(sessionID, id);
-    if (!isLocalCheckpoint(cut) || cut.id !== id || !row?.payload || row.digest !== foldDigest(row.payload))
-      return false;
-    const snapshot = JSON.parse(row.payload);
-    return snapshot.summary === cut.data.summary && snapshot.source === this.deps.storage.sourceID && snapshot.sessionID === sessionID && snapshot.admissionID === id;
+    return cut.id === id && isAdmittedLocalCheckpoint(this.deps.storage, sessionID, cut);
   }
   async idle(sessionID) {
     const { storage, session, threshold } = this.deps;
@@ -20869,6 +21898,25 @@ async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
 }
 
 // src/v2/hidden-completion.ts
+var DEFAULT_DISPOSE_DRAIN_MS = 2000;
+async function settleWithin(work, ms) {
+  let timer;
+  try {
+    await Promise.race([
+      work.then(() => {
+        return;
+      }, () => {
+        return;
+      }),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, Math.max(0, ms));
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 var POLL_INTERVAL_MS = 200;
 function modelKey(model) {
   return `${model.providerID}/${model.modelID}`;
@@ -20968,6 +22016,9 @@ function isProviderFailure(error) {
 }
 async function awaitAssistantRow(openReader, readSessionError, localFailure, childID, afterSeq, deadline, signal) {
   for (;; ) {
+    const refusedBefore = localFailure();
+    if (refusedBefore)
+      throw refusedBefore;
     const { assistant, idle } = withReader(openReader, (reader) => ({
       assistant: reader.latestAssistant(childID),
       idle: reader.latestIdle(childID)
@@ -21043,6 +22094,9 @@ async function createV2HiddenCompletionExecutor(host, options) {
   const generation = options.generation ?? "opencode2";
   const roleTails = new Map;
   const note = options.log ?? log;
+  let disposed;
+  const openRuns = new Set;
+  const inFlight = new Set;
   const removeSession = host.removeSession;
   if (!removeSession)
     throw new Error("Magic Context requires OpenCode 2.0.22 session.remove");
@@ -21079,7 +22133,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
       const entry = rows.find((row) => row && typeof row === "object" && row.providerID === model.providerID && row.id === model.modelID);
       if (!entry)
         return model;
-      if (entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
+      if (Array.isArray(entry.variants) ? entry.variants.some((variant) => variant?.id === model.variant) : entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
         return model;
       const key = `${model.providerID}/${model.modelID}:${model.variant}`;
       if (!warnedVariants.has(key)) {
@@ -21137,10 +22191,17 @@ async function createV2HiddenCompletionExecutor(host, options) {
   return {
     capabilities: V2_HIDDEN_EXECUTOR_CAPABILITIES,
     async open(identity) {
+      if (disposed)
+        throw disposed;
       const role = roleFor(identity);
-      const releaseRole = await acquireRole(role);
+      const releaseStore = options.holdStore?.() ?? (() => {});
+      let releaseRole;
       let openedChild;
+      let opened;
       try {
+        releaseRole = await acquireRole(role);
+        if (disposed)
+          throw disposed;
         await options.ensureAgent?.();
         const head = await resolveHead(identity);
         const active = await lifecycle.open(identity, role, head);
@@ -21151,17 +22212,25 @@ async function createV2HiddenCompletionExecutor(host, options) {
           role,
           child: active,
           releaseRole,
+          releaseStore,
           failed: false,
           unsettledFailure: false,
           retired: false
         };
         runs.set(handle, run);
+        opened = run;
+        openRuns.add(run);
+        if (disposed)
+          noteChildOfDisposedInstance(active.id);
         await switchChildModel(run, head);
         return handle;
       } catch (error) {
         if (openedChild)
           lifecycle.retire(openedChild, "hidden-run-open-failed");
-        releaseRole();
+        if (opened)
+          openRuns.delete(opened);
+        releaseRole?.();
+        releaseStore();
         throw error;
       }
     },
@@ -21169,6 +22238,15 @@ async function createV2HiddenCompletionExecutor(host, options) {
       const run = runs.get(handle);
       if (!run)
         throw new Error("Unknown hidden completion run");
+      const refuseDisposed = () => {
+        if (!disposed)
+          return;
+        run.failed = true;
+        run.unsettledFailure = true;
+        retire(run, "plugin-instance-disposed");
+        throw disposed;
+      };
+      refuseDisposed();
       if (request.signal?.aborted) {
         await interruptAndRetire(run, "aborted-before-prompt");
         throw new Error("Hidden completion prompt aborted");
@@ -21183,6 +22261,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
         handle.childSessionId = run.child.id;
       }
       await switchChildModel(run, requested);
+      refuseDisposed();
       const baseline = withReader(options.openReader, (reader) => reader.latestSequence(run.child.id));
       const marker = `mc:hidden:${crypto.randomUUID()}:${crypto.randomUUID()}`;
       run.completion = undefined;
@@ -21208,6 +22287,28 @@ async function createV2HiddenCompletionExecutor(host, options) {
         interruptAndRetire(run, "prompt-timeout").finally(() => abortReject(new Error("Hidden completion prompt timed out")));
       }, Math.max(0, deadline - Date.now()));
       request.signal?.addEventListener("abort", onAbort, { once: true });
+      let settle;
+      const entry = {
+        cancel: async (refusal) => {
+          attempt.refusal ??= refusal;
+          noteChildOfDisposedInstance(run.child.id);
+          try {
+            await interruptAndRetire(run, "plugin-instance-disposed");
+          } catch (error) {
+            note(`[magic-context] hidden child ${run.child.id} could not be interrupted on dispose: ${errorText(error)}`);
+          } finally {
+            abortReject(refusal);
+          }
+        },
+        reject: (refusal) => {
+          attempt.refusal ??= refusal;
+          abortReject(refusal);
+        },
+        settled: new Promise((resolve) => {
+          settle = resolve;
+        })
+      };
+      inFlight.add(entry);
       try {
         await Promise.race([
           host.prompt({ sessionID: run.child.id, text: marker }),
@@ -21278,6 +22379,8 @@ async function createV2HiddenCompletionExecutor(host, options) {
         clearTimeout(deadlineTimer);
         request.signal?.removeEventListener("abort", onAbort);
         options.hook.releaseAttempt(marker);
+        inFlight.delete(entry);
+        settle();
       }
     },
     async collect(handle) {
@@ -21299,9 +22402,27 @@ async function createV2HiddenCompletionExecutor(host, options) {
         }
       } finally {
         runs.delete(handle);
+        openRuns.delete(run);
         run.releaseRole();
+        run.releaseStore();
       }
       await lifecycle.finish(run.child, run.retired);
+    },
+    async dispose() {
+      disposed ??= new HiddenCompletionRefusal("hidden_instance_disposed", HIDDEN_RUN_DISPOSED_REASON, true);
+      const refusal = disposed;
+      for (const run of openRuns)
+        noteChildOfDisposedInstance(run.child.id);
+      const entries = [...inFlight];
+      if (entries.length === 0)
+        return;
+      note(`[magic-context] plugin instance disposed with ${entries.length} hidden run(s) in flight; cancelling them`);
+      const bound = options.disposeDrainMs ?? DEFAULT_DISPOSE_DRAIN_MS;
+      const deadline = Date.now() + bound;
+      await settleWithin(Promise.allSettled(entries.map((entry) => entry.cancel(refusal))), bound);
+      for (const entry of entries)
+        entry.reject(refusal);
+      await settleWithin(Promise.allSettled(entries.map((entry) => entry.settled)), deadline - Date.now());
     }
   };
 }
@@ -21531,26 +22652,70 @@ function generateReplayAnchor(messages) {
     return;
   return { id, tail: clonePreservingInstances(messages.slice(index + 1)) };
 }
+var DEFAULT_GENERATE_REPLAY_LIMITS = Object.freeze({
+  maxSessions: 16,
+  sessionMaxBytes: 128 * 1024 * 1024,
+  totalMaxBytes: 256 * 1024 * 1024
+});
 
 class V2GenerateReplay {
   prefixes = new Map;
+  totalBytes = 0;
+  limits;
+  constructor(limits = DEFAULT_GENERATE_REPLAY_LIMITS) {
+    if (!Number.isSafeInteger(limits.maxSessions) || limits.maxSessions < 1 || !Number.isSafeInteger(limits.sessionMaxBytes) || limits.sessionMaxBytes < 1 || !Number.isSafeInteger(limits.totalMaxBytes) || limits.totalMaxBytes < 1)
+      throw new Error("Generate replay limits must be positive integers");
+    this.limits = { ...limits };
+  }
   capture(draft, anchor) {
+    this.forget(draft.sessionID);
     if (!anchor) {
-      this.prefixes.delete(draft.sessionID);
       sessionLog(draft.sessionID, "generate replay capture skipped: no-anchor");
       return;
     }
+    const parts = {
+      anchor: clonePreservingInstancesMeasured(anchor),
+      system: clonePreservingInstancesMeasured(draft.system),
+      messages: clonePreservingInstancesMeasured(draft.messages),
+      tools: clonePreservingInstancesMeasured(draft.tools)
+    };
+    const bytes = 256 + parts.anchor.bytes + parts.system.bytes + parts.messages.bytes + parts.tools.bytes;
+    if (bytes > this.limits.sessionMaxBytes || bytes > this.limits.totalMaxBytes) {
+      sessionLog(draft.sessionID, `generate replay capture skipped: over-session-cap (${bytes} > ${Math.min(this.limits.sessionMaxBytes, this.limits.totalMaxBytes)} bytes)`);
+      return;
+    }
+    while (this.prefixes.size > 0 && (this.prefixes.size >= this.limits.maxSessions || this.totalBytes + bytes > this.limits.totalMaxBytes)) {
+      const oldest = this.prefixes.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.forget(oldest);
+    }
     this.prefixes.set(draft.sessionID, {
-      anchor: clonePreservingInstances(anchor),
+      anchor: parts.anchor.copy,
       model: `${draft.model.providerID}/${draft.model.id}`,
       agent: draft.agent,
-      system: clonePreservingInstances(draft.system),
-      messages: clonePreservingInstances(draft.messages),
-      tools: clonePreservingInstances(draft.tools)
+      system: parts.system.copy,
+      messages: parts.messages.copy,
+      tools: parts.tools.copy,
+      bytes
     });
+    this.totalBytes += bytes;
   }
   forget(sessionID) {
+    const prefix = this.prefixes.get(sessionID);
+    if (!prefix)
+      return;
     this.prefixes.delete(sessionID);
+    this.totalBytes -= prefix.bytes;
+  }
+  stats() {
+    return {
+      totalBytes: this.totalBytes,
+      sessions: [...this.prefixes].map(([sessionId, prefix]) => ({
+        sessionId,
+        bytes: prefix.bytes
+      }))
+    };
   }
   apply(draft) {
     const prefix = this.prefixes.get(draft.sessionID);
@@ -21560,6 +22725,8 @@ class V2GenerateReplay {
     };
     if (!prefix)
       return skip("no-prefix");
+    this.prefixes.delete(draft.sessionID);
+    this.prefixes.set(draft.sessionID, prefix);
     if (prefix.model !== `${draft.model.providerID}/${draft.model.id}`)
       return skip("model-mismatch");
     if (prefix.agent !== draft.agent)
@@ -21588,9 +22755,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function identity(slot) {
-  return createHash5("sha256").update(JSON.stringify({
+  return createHash4("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -21603,21 +22770,25 @@ function identity(slot) {
 
 class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
-  capture(sessionId, slot, input, served) {
+  capture(sessionId, slot, input, served, head) {
     this.systems.set(sessionId, {
       slot: identity(slot),
-      input: JSON.stringify(input),
-      served: structuredClone(served)
+      input: hostInputKey(input),
+      served: structuredClone(served),
+      head: head ? structuredClone(head) : null
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
-      return false;
+    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== hostInputKey(input))
+      return;
     target.splice(0, target.length, ...structuredClone(saved.served));
-    return true;
+    return { head: saved.head ? structuredClone(saved.head) : null };
   }
 }
+function hostInputKey(input) {
+  return JSON.stringify({ system: input.system, checkpoint: input.checkpoint });
+}
 
 // src/v2/hooks/model-limit-cache.ts
 var warmStarted = false;
@@ -22278,6 +23449,22 @@ function* readV2RawMessagePagesForConversion(openReader, sessionID, pageRows = C
 function createV2RawMessageReader(openReader) {
   const servedBoundaryCache = new Map;
   return {
+    getRevision: (sessionID) => {
+      const reader = openReader();
+      try {
+        return reader.latestSequence(sessionID);
+      } finally {
+        reader.close();
+      }
+    },
+    getCountAfterRevision: (sessionID, after, through) => {
+      const reader = openReader();
+      try {
+        return reader.messageCountAfterSequence(sessionID, after, through);
+      } finally {
+        reader.close();
+      }
+    },
     readPage: (sessionID, afterOrdinal, limit, finalWatermark, after) => {
       const reader = openReader();
       try {
@@ -22553,7 +23740,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -22777,7 +23964,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord4(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash6("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash5("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   if (!selected)
     return `Tag ${number}'s original text part is no longer in stored history.`;
@@ -23745,7 +24932,7 @@ function createCtxReduceTool(deps) {
       args = unwrapImitatedReducedArgs(args, ["drop"], { drop: "string" });
       const sessionId = toolContext.sessionID;
       if (!args.drop) {
-        return "Error: 'drop' must be provided.";
+        return `Error: 'drop' must be provided as a string of tag numbers, for example {"drop": "3-5,8"}.`;
       }
       let dropIds = [];
       try {
@@ -24127,7 +25314,28 @@ function persistV2UsageReading(args) {
 }
 
 // src/v2/hooks/context.ts
+function applyCheckpointHead(draft, head) {
+  const { checkpoint, submitted } = head;
+  const first = draft.messages.find((message) => message.id === HEAD_IDS[0]);
+  const baseline = first?.content.find((part) => part.type === "text")?.text;
+  if (typeof baseline !== "string")
+    return false;
+  for (const part of checkpoint.content)
+    if (part.type === "text" && typeof part.text === "string") {
+      part.text = part.text.replace(`<summary>
+${submitted}
+</summary>`, `<summary>
+${baseline}
+</summary>`);
+    }
+  const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
+  if (volatile && first)
+    volatile.content.push(...first.content.filter((part) => part.type !== "text"));
+  draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== first));
+  return true;
+}
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
+var STORE_POOL_DISPOSE_WAIT_MS = 1000;
 
 class V2LkgAdmissionReplay extends Error {
 }
@@ -24349,11 +25557,12 @@ async function registerContext(context) {
   }
   const folds = new FoldOwner(context.storage);
   const nativeFoldMemory = !compactionOff && process.env.MMC_OC2_INVISIBLE_FOLD === "1" ? nativeFoldCache(() => storage.require()) : undefined;
-  const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader()) : undefined;
+  const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader(), context.storage) : undefined;
   setOutputReserveConfig(config.output_reserve);
   const queriedModels = new Set;
   const rawLimits = new Map;
   const hiddenSessionErrors = new Map;
+  const committedSourceRefreshes = new Map;
   const liveModels = new Map;
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode2",
@@ -24467,6 +25676,7 @@ async function registerContext(context) {
       ensureAgent: () => hiddenAgentsReady ??= context.agent.reload(),
       modelCatalog: () => Promise.resolve(context.model.list()),
       openReader: openStoreReader,
+      holdStore: () => readerPool.hold(),
       resolveStepCap: resolveHiddenStepCap
     });
   };
@@ -24552,11 +25762,17 @@ async function registerContext(context) {
     }
   });
   const pagedRead = createV2RawMessageReader(openStoreReader);
+  let orphanSweep;
+  let orphanSweepTimer;
   const prepareHistorySession = (sessionID) => {
     if (!rawProviders.has(sessionID))
       rawProviders.set(sessionID, setBoundedRawMessageProvider2(sessionID, createV2RawMessageProvider(pagedRead, sessionID)));
   };
   if (db && isDatabasePersisted(db)) {
+    const sweepDb = db;
+    orphanSweepTimer = scheduleAfterBootQuiet(() => {
+      orphanSweep = sweepOrphanedOpenCodeMessageIndexesCooperatively(sweepDb, () => new Database(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"), { readonly: true, fileMustExist: true })).catch((error) => log("[magic-context] v2 orphan sweep failed:", error));
+    });
     const backfillDb = db;
     scheduleAfterBootQuiet(() => {
       runV2SessionProjectBackfill(backfillDb, openStoreReader, config.allow_home_project).catch((error) => log("[session-project-backfill] OpenCode 2 backfill failed:", error));
@@ -24675,88 +25891,122 @@ async function registerContext(context) {
   }) : undefined;
   const usageController = new AbortController;
   const usageDone = (async () => {
-    try {
-      for await (const value of context.event.subscribe({ signal: usageController.signal })) {
-        if (usageController.signal.aborted)
-          break;
-        const event = value;
-        if (!event.data?.sessionID)
-          continue;
-        const sessionID = event.data.sessionID;
-        if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
-          nativeFoldReplay?.onEvent(event);
-          restoredRows.forget(sessionID);
-        }
-        if (event.type?.startsWith("session.revert.") && db) {
-          const database = db;
-          withoutSqliteTransformPass(() => scheduleClearAndReindex(database, sessionID, pagedRead));
-        }
-        if (event.type === "session.error" || event.type === "session.execution.failed") {
-          const error = hiddenTerminalError(event);
-          if (error !== undefined)
-            hiddenSessionErrors.set(sessionID, error);
-          if (error !== undefined && db && !compactionOff) {
+    let retry = 0;
+    while (!usageController.signal.aborted) {
+      const subscribedAt = Date.now();
+      try {
+        for await (const value of context.event.subscribe({
+          signal: usageController.signal
+        })) {
+          if (usageController.signal.aborted)
+            break;
+          const event = value;
+          try {
+            if (event.type === "provider.updated" || event.type === "model.updated") {
+              queriedModels.clear();
+              continue;
+            }
+            if (!event.data?.sessionID)
+              continue;
+            const sessionID = event.data.sessionID;
+            if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
+              nativeFoldReplay?.onEvent(event);
+              restoredRows.forget(sessionID);
+            }
+            if (event.type === "session.revert.committed") {
+              committedSourceRefreshes.set(sessionID, {});
+              const database = db;
+              if (database)
+                withoutSqliteTransformPass(() => scheduleClearAndReindex(database, sessionID, pagedRead));
+            }
+            if (event.type === "session.error" || event.type === "session.execution.failed") {
+              const error = hiddenTerminalError(event);
+              if (error !== undefined)
+                hiddenSessionErrors.set(sessionID, error);
+              if (error !== undefined && db && !compactionOff) {
+                const model = liveModels.get(sessionID);
+                try {
+                  armLatestThinkingRecoveryFromError({
+                    db,
+                    sessionId: sessionID,
+                    error,
+                    providerID: model?.providerID,
+                    modelID: model?.modelID
+                  });
+                } catch (armError) {
+                  log("[magic-context] v2 latest-thinking recovery arm failed", armError);
+                }
+              }
+              continue;
+            }
+            if (event.type === "session.deleted") {
+              committedSourceRefreshes.delete(sessionID);
+              clearLkgMeasuredRequest(sessionID);
+              deletedSessions.add(sessionID);
+              transform?.clearSessionLogState(sessionID);
+              if (db) {
+                markSessionCleanupPending(db, sessionID);
+                clearSession(db, sessionID, false, true);
+              }
+              rawProviders.get(sessionID)?.();
+              rawProviders.delete(sessionID);
+              usage.delete(sessionID);
+              hiddenSessionErrors.delete(sessionID);
+              storageNoticeBySession.delete(sessionID);
+              liveModels.delete(sessionID);
+              variants.delete(sessionID);
+              agents.delete(sessionID);
+              channel1.delete(sessionID);
+              historyRefreshSessions.delete(sessionID);
+              clearPendingMaterialization(pendingMaterializationSessions, sessionID);
+              lastHeuristicsTurnId.delete(sessionID);
+              restoredRows.forget(sessionID);
+              if (nativeFoldReplay)
+                await nativeFoldReplay.forget(sessionID);
+              else
+                await forgetNativeFoldProvenance(context.storage, sessionID);
+              generateReplay.forget(sessionID);
+              systemPromptRefreshSessions.delete(sessionID);
+              systemPrompt?.clearSession(sessionID);
+              clearMaintenanceSystemSnapshot(sessionID);
+              tagger.cleanup(sessionID);
+              sessionDirectories.delete(sessionID);
+              forkSeedSettled.delete(sessionID);
+              continue;
+            }
+            if (event.type !== "session.execution.succeeded")
+              continue;
             const model = liveModels.get(sessionID);
-            try {
-              armLatestThinkingRecoveryFromError({
-                db,
-                sessionId: sessionID,
-                error,
-                providerID: model?.providerID,
-                modelID: model?.modelID
+            if (model) {
+              await recordUsage({
+                sessionID,
+                model: { providerID: model.providerID, id: model.modelID }
               });
-            } catch (armError) {
-              log("[magic-context] v2 latest-thinking recovery arm failed", armError);
+              if (!compactionOff && typeof await nativeFoldReplay?.baseline(sessionID) === "string")
+                hostFolds?.idle(sessionID);
             }
+          } catch (error) {
+            log(`[magic-context] v2 event handler failed (type=${event.type ?? "unknown"}, session=${event.data?.sessionID ?? "none"})`, error);
           }
-          continue;
-        }
-        if (event.type === "session.deleted") {
-          clearLkgMeasuredRequest(sessionID);
-          deletedSessions.add(sessionID);
-          transform?.clearSessionLogState(sessionID);
-          if (db) {
-            markSessionCleanupPending(db, sessionID);
-            clearSession(db, sessionID);
-          }
-          rawProviders.get(sessionID)?.();
-          rawProviders.delete(sessionID);
-          usage.delete(sessionID);
-          hiddenSessionErrors.delete(sessionID);
-          storageNoticeBySession.delete(sessionID);
-          liveModels.delete(sessionID);
-          variants.delete(sessionID);
-          agents.delete(sessionID);
-          channel1.delete(sessionID);
-          historyRefreshSessions.delete(sessionID);
-          clearPendingMaterialization(pendingMaterializationSessions, sessionID);
-          lastHeuristicsTurnId.delete(sessionID);
-          restoredRows.forget(sessionID);
-          await nativeFoldReplay?.forget(sessionID);
-          generateReplay.forget(sessionID);
-          systemPromptRefreshSessions.delete(sessionID);
-          systemPrompt?.clearSession(sessionID);
-          clearMaintenanceSystemSnapshot(sessionID);
-          tagger.cleanup(sessionID);
-          sessionDirectories.delete(sessionID);
-          forkSeedSettled.delete(sessionID);
-          continue;
-        }
-        if (event.type !== "session.execution.succeeded")
-          continue;
-        const model = liveModels.get(sessionID);
-        if (model) {
-          await recordUsage({
-            sessionID,
-            model: { providerID: model.providerID, id: model.modelID }
-          });
-          if (!compactionOff && typeof await nativeFoldReplay?.baseline(sessionID) === "string")
-            hostFolds?.idle(sessionID);
         }
+      } catch (error) {
+        if (!usageController.signal.aborted)
+          log("[magic-context] v2 usage subscription failed", error);
+      }
+      if (usageController.signal.aborted)
+        break;
+      if (Date.now() - subscribedAt >= 30000)
+        retry = 0;
+      const ceiling = Math.min(30000, 250 * 2 ** retry);
+      retry = Math.min(retry + 1, 7);
+      try {
+        await delay(ceiling * (0.5 + Math.random() * 0.5), undefined, {
+          signal: usageController.signal
+        });
+      } catch (error) {
+        if (!usageController.signal.aborted)
+          throw error;
       }
-    } catch (error) {
-      if (!usageController.signal.aborted)
-        log("[magic-context] v2 usage subscription failed", error);
     }
   })();
   const materialize = (draft) => {
@@ -24829,20 +26079,57 @@ async function registerContext(context) {
       reader.close();
     }
   });
+  const restoreAfterCheckpoint = (args) => {
+    const { db, reader, draft, cut, boundaryRepair } = args;
+    const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
+    const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
+    const boundary = servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
+    const present = new Set(args.messages.map((message) => message.id));
+    const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: (detail) => sessionLog(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
+    } : undefined));
+    const covered = reader.instructionRowsThrough(draft.sessionID, Math.min(boundary, cut.seq)).flatMap((row) => restoreRow(row, draft.model)).map((message) => markCoveredInstructionRow(message));
+    return [
+      ...covered,
+      ...restored,
+      ...args.messages.filter((message) => message !== args.incoming)
+    ];
+  };
+  const temporalTimes = config.temporal_awareness === true;
+  const anchorTimesOnly = !temporalTimes;
+  const timeIds = (messages) => {
+    if (temporalTimes)
+      return messages.flatMap((message) => message.id ? [message.id] : []);
+    const ids = [];
+    for (const message of [...messages].reverse()) {
+      if (message.id)
+        ids.push(message.id);
+      if (message.role === "assistant")
+        break;
+    }
+    return ids;
+  };
   const runManagedContext = async (draft) => {
     rememberHostMedia(draft.messages);
     if (hiddenChildHook.apply(draft))
       return;
     if (deletedSessions.has(draft.sessionID))
       return;
-    const systemAtEntry = structuredClone(draft.system);
+    let systemAtEntry = structuredClone(draft.system);
     const slotAtEntry = getSlot(draft.sessionID);
+    let checkpointAtEntry;
+    let replayHead;
+    const hostInput = () => checkpointAtEntry === undefined ? undefined : { system: systemAtEntry, checkpoint: checkpointAtEntry };
     const restoreLkgSystem = () => {
       retirePendingSystemPromptDelivery(draft.sessionID);
-      if (!lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), systemAtEntry, draft.system)) {
+      const input = hostInput();
+      const restored = input && lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, draft.system);
+      if (!restored) {
         sessionLog(draft.sessionID, "lkg_system_state_mismatch");
         throw new Error("LKG system identity is unavailable or changed");
       }
+      replayHead = restored.head;
     };
     const isMagicContextSynthetic = (id) => isAdmittedSynthetic(context, draft.sessionID, id);
     const newest = draft.messages.at(-1);
@@ -24851,6 +26138,24 @@ async function registerContext(context) {
       return;
     }
     await dropStorageNotices(draft.messages, isMagicContextSynthetic);
+    let hostMessagesAtEntry = [...draft.messages];
+    const passTimes = new Map;
+    const readTimes = (reader, messages) => {
+      const ids = timeIds(messages);
+      const missing = ids.filter((id) => !passTimes.has(id));
+      if (missing.length) {
+        const read = reader.messageTimes(draft.sessionID, missing);
+        for (const id of missing)
+          passTimes.set(id, read.get(id) ?? null);
+      }
+      const times = new Map;
+      for (const id of ids) {
+        const time = passTimes.get(id);
+        if (time)
+          times.set(id, time);
+      }
+      return times;
+    };
     liveModels.set(draft.sessionID, {
       providerID: draft.model.providerID,
       modelID: draft.model.id
@@ -24862,8 +26167,9 @@ async function registerContext(context) {
     applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface);
     const admissionDb = db ?? storage.current();
     const replayFits = (messages) => {
-      const system = structuredClone(draft.system);
-      if (!admissionDb || !draft.tools || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), draft.system, system))
+      const system = [];
+      const input = hostInput();
+      if (!admissionDb || !draft.tools || !input || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), input, system))
         return false;
       const limit = lkgReplayLimit({
         db: admissionDb,
@@ -24898,15 +26204,75 @@ async function registerContext(context) {
         })
       }).fit === "under";
     };
+    const buildReplayInput = async () => {
+      let messages = [...hostMessagesAtEntry];
+      const admitted = new Set;
+      let times;
+      try {
+        const reader = openStoreReader();
+        try {
+          const cut = reader.latestCompaction(draft.sessionID);
+          const localCut = cut && isLocalCheckpoint(cut) ? cut : undefined;
+          const incoming = localCut && messages.find((message) => message.id === localCut.id);
+          if (localCut && !incoming || cut && nativeFoldReplay)
+            return;
+          checkpointAtEntry = incoming || null;
+          const modeDb = db ?? storage.current();
+          const subagent = modeDb ? storedSubagentMode(modeDb, draft.sessionID) : undefined;
+          if (subagent === undefined)
+            return;
+          if (subagent)
+            removePrimaryOnlyTools(draft.tools);
+          const candidates = syntheticCandidates(context, draft.sessionID, reader.syntheticMessageIDs(draft.sessionID));
+          for (const message of messages)
+            if (message.id && candidates.has(message.id) && await isAdmittedSynthetic(context, draft.sessionID, message.id))
+              admitted.add(message.id);
+          const replayDb = db ?? storage.current();
+          if (localCut && incoming && replayDb)
+            messages = restoreAfterCheckpoint({
+              db: replayDb,
+              reader,
+              draft,
+              messages,
+              cut: localCut,
+              incoming,
+              boundaryRepair: undefined
+            });
+          else if (localCut)
+            return;
+          times = readTimes(reader, messages);
+        } finally {
+          reader.close();
+        }
+      } catch (error) {
+        sessionLog(draft.sessionID, "lkg replay input unavailable", error);
+        return;
+      }
+      const replayDraft = { ...draft, messages };
+      return {
+        draft: replayDraft,
+        mapped: adaptPayload(replayDraft, admitted, times, anchorTimesOnly)
+      };
+    };
+    const adoptReplay = (replayed) => {
+      draft.messages.splice(0, draft.messages.length, ...replayed.messages);
+      if (replayHead)
+        applyCheckpointHead(draft, replayHead);
+    };
     let postFold = false;
     try {
       if (!compactionOff && admissionDb)
         await withAsyncPrivilegedWriter(admissionDb, () => {
           return;
         }, {
-          beforeRetry: (_error) => {
+          beforeRetry: async (_error) => {
+            hostMessagesAtEntry = [...draft.messages];
+            systemAtEntry = structuredClone(draft.system);
             let replayBlocked = false;
-            const mapped = adaptPayload(draft);
+            const input = await buildReplayInput();
+            if (!input)
+              return;
+            const { mapped } = input;
             try {
               const overflowDb = db;
               if (overflowDb !== undefined && overflowDb !== null && (isEmergencyRecoveryArmed(draft.sessionID) || getOverflowState(overflowDb, draft.sessionID).needsEmergencyRecovery)) {
@@ -24927,6 +26293,7 @@ async function registerContext(context) {
                   restoreLkgSystem();
                   mapped.messages.splice(0, mapped.messages.length, ...replay.messages);
                   mapped.commit();
+                  adoptReplay(input.draft);
                   sessionLog(draft.sessionID, "lkg_replay_served");
                   throw new V2LkgAdmissionReplay;
                 } else {
@@ -24943,6 +26310,8 @@ async function registerContext(context) {
               sessionLog(draft.sessionID, "lkg_replay_declined");
           }
         });
+      hostMessagesAtEntry = [...draft.messages];
+      systemAtEntry = structuredClone(draft.system);
       if (admissionDb)
         hideSubagentTools(draft, admissionDb);
       recordV2ToolDefinitions(draft);
@@ -25046,7 +26415,11 @@ async function registerContext(context) {
         contextUsageMap: usage,
         compactionOff,
         storeGeneration: "v2",
-        normalizeRestoredAssistantText: stripCopiedTagNotation,
+        normalizeRestoredAssistantText: (text, providerID) => {
+          const normalized = stripCopiedTagNotation(text);
+          return normalized === "" && !modelAcceptsEmptyContent(providerID) ? text : normalized;
+        },
+        refreshSourceContents: (sessionID) => committedSourceRefreshes.has(sessionID),
         hostCleanupCompactionMarkers: () => ({
           verified: true,
           removedLineages: 0,
@@ -25073,7 +26446,7 @@ async function registerContext(context) {
         sessionDirectoryBySession: sessionDirectories,
         projectPath: directory,
         agentBySession: agents,
-        maintenanceConfig: config.maintenance ? () => config.maintenance : undefined,
+        maintenanceConfig: config.maintenance ? () => inheritMaintenanceModelConfig(config) : undefined,
         hiddenCompletionExecutor,
         historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
         historianModel: historianModels.primary,
@@ -25091,8 +26464,14 @@ async function registerContext(context) {
         },
         ...createHostSeams(context, readAllForConversion, pagedRead, liveModels)
       });
+      const refreshToken = committedSourceRefreshes.get(draft.sessionID);
+      if (refreshToken) {
+        clearCachedM0(db, draft.sessionID);
+        restoredRows.forget(draft.sessionID);
+      }
       const admitted = new Set;
       const reader = openStoreReader();
+      let messageTimes;
       let checkpoint;
       let submitted;
       try {
@@ -25107,12 +26486,14 @@ async function registerContext(context) {
           historyRefreshSessions.add(draft.sessionID);
           requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "boundary_repair");
         }
-        const incoming = cut && draft.messages.find((message) => message.id === cut.id);
+        const localCut = cut && isLocalCheckpoint(cut) ? cut : undefined;
+        const incoming = localCut && draft.messages.find((message) => message.id === localCut.id);
         postFold = cut !== undefined;
-        if (cut && !incoming)
+        checkpointAtEntry = incoming || null;
+        if (localCut && !incoming)
           throw new Error("The host checkpoint disappeared from the context draft");
         let nativeRestored;
-        if (cut && nativeFoldReplay && isLocalCheckpoint(cut)) {
+        if (cut && nativeFoldReplay && await nativeFoldReplay.admits(draft.sessionID, cut, reader)) {
           try {
             nativeRestored = await nativeFoldReplay.restore(draft.sessionID, cut, `${draft.model.providerID}/${draft.model.id}`, { bounded: true });
           } catch (error) {
@@ -25121,7 +26502,7 @@ async function registerContext(context) {
             nativeRestored = await nativeFoldReplay.restoreRead(draft.sessionID, cut, draft.model);
           }
         }
-        if (nativeRestored && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
+        if (cut && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
           historyRefreshSessions.add(draft.sessionID);
           requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_history_change");
         }
@@ -25132,30 +26513,33 @@ async function registerContext(context) {
             return !id || !present.has(id);
           });
           draft.messages.splice(0, draft.messages.length, ...hidden, ...draft.messages.filter((message) => message !== incoming));
-        } else if (cut && incoming) {
-          const identity = await folds.observe({
-            sessionID: draft.sessionID,
-            cutSeq: cut.seq,
-            summary: cut.data.summary ?? "",
-            rendered: incoming,
-            onHard: (reason) => {
-              log(`[magic-context] HARD reason=${reason} session=${draft.sessionID}`);
-              materialize(draft);
-              requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
-            }
-          });
-          checkpoint = structuredClone(identity.rendered ?? incoming);
-          submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
-          const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
-          const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
-          const boundary = servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
-          const present = new Set(draft.messages.map((message) => message.id));
-          const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
-            asset: hostMediaAsset,
-            unavailable: (detail) => sessionLog(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
-          } : undefined));
-          draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
+        } else if (localCut && cut && incoming) {
+          if (!nativeFoldReplay) {
+            const identity = await folds.observe({
+              sessionID: draft.sessionID,
+              cutSeq: cut.seq,
+              summary: cut.data.summary ?? "",
+              rendered: incoming,
+              onHard: (reason) => {
+                log(`[magic-context] HARD reason=${reason} session=${draft.sessionID}`);
+                materialize(draft);
+                requestPendingMaterialization(pendingMaterializationSessions, draft.sessionID, "host_compaction");
+              }
+            });
+            checkpoint = structuredClone(identity.rendered ?? incoming);
+            submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
+          }
+          draft.messages.splice(0, draft.messages.length, ...restoreAfterCheckpoint({
+            db,
+            reader,
+            draft,
+            messages: draft.messages,
+            cut: localCut,
+            incoming,
+            boundaryRepair
+          }));
         }
+        messageTimes = readTimes(reader, draft.messages);
       } finally {
         reader.close();
       }
@@ -25167,31 +26551,18 @@ async function registerContext(context) {
           nativeFoldReplay.invalidate(draft.sessionID, true);
         }
       }
-      const mapped = adaptPayload(draft, admitted);
+      const mapped = adaptPayload(draft, admitted, messageTimes, anchorTimesOnly);
       bindSystemDateRequestIdentity(mapped, draft);
       await transform({}, mapped);
       mapped.commit();
+      if (refreshToken && committedSourceRefreshes.get(draft.sessionID) === refreshToken)
+        committedSourceRefreshes.delete(draft.sessionID);
       if (db) {
         await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
       }
-      if (checkpoint && submitted !== undefined) {
-        const head = draft.messages.find((message) => message.id === HEAD_IDS[0]);
-        const baseline = head?.content.find((part) => part.type === "text")?.text;
-        if (typeof baseline === "string") {
-          for (const part of checkpoint.content)
-            if (part.type === "text" && typeof part.text === "string") {
-              part.text = part.text.replace(`<summary>
-${submitted}
-</summary>`, `<summary>
-${baseline}
-</summary>`);
-            }
-          const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
-          if (volatile && head)
-            volatile.content.push(...head.content.filter((part) => part.type !== "text"));
-          draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
-        }
-      }
+      const head = replayHead !== undefined ? replayHead : checkpoint && submitted !== undefined ? { checkpoint, submitted } : null;
+      const servedHead = head && structuredClone(head);
+      const headApplied = head ? applyCheckpointHead(draft, head) : false;
       if (nativeMessages && !checkpoint) {
         try {
           await nativeFoldReplay?.capture(draft, nativeMessages);
@@ -25202,7 +26573,7 @@ ${baseline}
       }
       const capturedSlot = getSlot(draft.sessionID);
       if (capturedSlot && (!slotAtEntry || capturedSlot.capturedAt !== slotAtEntry.capturedAt || capturedSlot.captureSequence !== slotAtEntry.captureSequence || capturedSlot.jsonPrefix !== slotAtEntry.jsonPrefix)) {
-        lkgSystems.capture(draft.sessionID, capturedSlot, systemAtEntry, draft.system);
+        lkgSystems.capture(draft.sessionID, capturedSlot, { system: systemAtEntry, checkpoint: checkpointAtEntry ?? null }, draft.system, headApplied ? servedHead : null);
       }
     } catch (error) {
       if (error instanceof V2ContextRefusal)
@@ -25228,7 +26599,10 @@ ${baseline}
               replayBlocked = true;
               sessionLog(draft.sessionID, "lkg_emergency_armed");
             } else {
-              const replayMapped = adaptPayload(draft);
+              const input = await buildReplayInput();
+              if (!input)
+                throw new StorageBusyRefusalError(error, "v2-context");
+              const replayMapped = input.mapped;
               const keys = resolveLkgModelKeys(replayMapped.messages);
               const replay = replayLkg({
                 sessionId: draft.sessionID,
@@ -25242,6 +26616,8 @@ ${baseline}
                 restoreLkgSystem();
                 replayMapped.messages.splice(0, replayMapped.messages.length, ...replay.messages);
                 replayMapped.commit();
+                adoptReplay(input.draft);
+                sessionLog(draft.sessionID, "lkg_replay_served");
                 return;
               } else {
                 sessionLog(draft.sessionID, replay.reason);
@@ -25386,17 +26762,23 @@ ${baseline}
   }, 0);
   return {
     async dispose() {
+      usageController.abort();
+      if (orphanSweepTimer)
+        clearTimeout(orphanSweepTimer);
+      await hiddenCompletionExecutor?.dispose();
+      await usageDone;
+      await orphanSweep;
       rpcStopped = true;
       rpcServer.stop();
       tools?.dispose();
-      usageController.abort();
-      await usageDone;
       deletedSessions.clear();
+      committedSourceRefreshes.clear();
       for (const release of rawProviders.values())
         release();
       rawProviders.clear();
       restoredRows.clear();
-      readerPool.close();
+      if (!await readerPool.closeWhenIdle(STORE_POOL_DISPOSE_WAIT_MS))
+        log(`[magic-context] v2 store reader pool still held by ${readerPool.holdCount()} hidden run(s) at dispose; it closes when they finish`);
       clearSyntheticCandidates(context);
     }
   };