@retaw106/mmc-oc 2.0.0 → 2.1.0

package/dist/{context-95zkksn3.js → context-vhcstgs3.js}

@@ -102,6 +102,7 @@ import {
   resolveCompactionModeRecord,
   getCompactionModeRecord,
   setCompactionModeRecord,
+  getProtectedTailDrainBudgetSkip,
   clearPersistedReasoningWatermark,
   getEmergencyInputSample,
   setEmergencyDropSample,
@@ -246,13 +247,15 @@ import {
   hasCompleteCachedM0M1,
   injectM0M1,
   RECOVERY_NO_HEAD_LIMIT,
+  deriveProtectedTailTokenTarget,
+  selectPerRunCap,
   resolveOpenCodeProtectedTailBoundary,
   getRawHistoryEligibility,
   hasRunnableCompartmentWindow,
   recordHighPressureNoEligibleHead,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-bdt9my9y.js";
+} from "./index-wtb9hzk6.js";
 import {
   getHarness,
   getDataDir,
@@ -386,6 +389,7 @@ import {
   getMeasuredToolDefinitionTokens,
   describeFinalWireTail,
   estimateMessageTokens,
+  wireContentBytes,
   createFinalWireUsageTracker,
   estimateFinalWireInputTokens,
   modelAcceptsEmptyContent,
@@ -412,7 +416,7 @@ import {
   primeInMemoryTailRawMessageCache2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-1mjhzqq7.js";
+} from "./index-dr0gepzw.js";
 import {
   getSqliteMemoryStats,
   withSqliteBackgroundWriter,
@@ -421,7 +425,7 @@ import {
   isTransientSqliteError,
   SqliteAcquisitionBusyError,
   withAsyncPrivilegedWriter
-} from "./index-fg34g6a5.js";
+} from "./index-1j34a56j.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -435,7 +439,7 @@ import {
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-977gxfz0.js";
+} from "./index-ramz5kkm.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -448,7 +452,7 @@ import {
   getErrorMessage,
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./index-5pg0acf7.js";
+} from "./index-amycb7b1.js";
 import {
   resolveHistorianModel2
 } from "./index-z2g20msd.js";
@@ -3034,6 +3038,10 @@ function sampleLiveConfig(boot, fresh) {
     let value = fresh;
     for (const part of parts)
       value = value?.[part];
+    if (value === undefined) {
+      removeLeaf(result, parts);
+      continue;
+    }
     let target = result;
     for (const part of parts.slice(0, -1)) {
       const child = target[part];
@@ -3047,6 +3055,26 @@ function sampleLiveConfig(boot, fresh) {
   }
   return result;
 }
+function removeLeaf(root, parts) {
+  const parents = parts.slice(0, -1);
+  let node = root;
+  for (const part of parents) {
+    const child = node[part];
+    if (!child || typeof child !== "object" || Array.isArray(child))
+      return;
+    node = child;
+  }
+  const leaf = parts.at(-1);
+  if (leaf === undefined || !Object.hasOwn(node, leaf))
+    return;
+  let target = root;
+  for (const part of parents) {
+    const copy = { ...target[part] };
+    target[part] = copy;
+    target = copy;
+  }
+  delete target[leaf];
+}
 function changedLiveKeys(previous, next) {
   const at = (config, path) => path.split(".").reduce((node, part) => node?.[part], config);
   return LIVE_RELOAD_CONFIG_PATHS.filter((path) => JSON.stringify(at(previous, path)) !== JSON.stringify(at(next, path)));
@@ -8599,6 +8627,9 @@ function createToolExecuteAfterHook(args) {
   };
 }
 
+// src/hooks/magic-context/lkg-measured-request.ts
+import { createHash as createHash3 } from "node:crypto";
+
 // src/shared/provider-response-completion.ts
 function providerResponseFailed(input) {
   if (input.error !== undefined && input.error !== null && input.error !== "")
@@ -8620,9 +8651,49 @@ function lkgProviderInputTotal(tokens) {
   const counts = [tokens?.input ?? 0, tokens?.cache?.read ?? 0, tokens?.cache?.write ?? 0];
   return counts.every((count) => Number.isSafeInteger(count) && count >= 0) ? counts.reduce((sum, count) => sum + count, 0) : Number.NaN;
 }
+function identity(slot) {
+  return createHash3("sha256").update(JSON.stringify([
+    slot.capturedAt,
+    slot.captureSequence,
+    slot.rowVersion,
+    slot.modelKey,
+    slot.providerKey,
+    slot.inputIdSeq,
+    slot.inputContentDigests
+  ])).update(slot.jsonPrefix).digest("hex");
+}
+function envelope(modelKey, systemPromptTokens, agentName) {
+  const slash = modelKey.indexOf("/");
+  return JSON.stringify([
+    modelKey,
+    systemPromptTokens,
+    agentName,
+    getMeasuredToolDefinitionTokens(modelKey.slice(0, slash), modelKey.slice(slash + 1), agentName)
+  ]);
+}
 function beginV2LkgRequest(sessionId, modelKey, previousResponseId) {
   requests.set(sessionId, { kind: "v2", previousResponseId, startedAt: Date.now(), modelKey });
 }
+function claimLkgRequestIdentity(sessionId) {
+  const request = requests.get(sessionId);
+  if (!request || claimedRequests.has(request))
+    return;
+  claimedRequests.add(request);
+  return request;
+}
+function noteCapturedLkgRequest(args) {
+  const request = args.request;
+  if (!request || request.modelKey !== args.slot.modelKey) {
+    captures.delete(args.sessionId);
+    return;
+  }
+  captures.set(args.sessionId, {
+    request,
+    slot: identity(args.slot),
+    prefixCount: JSON.parse(args.slot.jsonPrefix).length,
+    envelope: envelope(request.modelKey, args.systemPromptTokens, args.agentName)
+  });
+}
 function noteLkgProviderResponse(args) {
   if (!args.responseId || !args.modelKey)
     return;
@@ -8650,7 +8721,7 @@ function noteLkgProviderResponse(args) {
 }
 
 // src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function parseStringArray(value) {
   if (typeof value !== "string")
     return null;
@@ -8764,7 +8835,7 @@ function rememberFingerprint(db, sessionId, fingerprint) {
   saved.set(sessionId, fingerprint);
 }
 function slotFingerprint(slot) {
-  return createHash3("sha256").update(JSON.stringify([
+  return createHash4("sha256").update(JSON.stringify([
     slot.jsonPrefix,
     slot.inputIdSeq,
     slot.inputContentDigests,
@@ -9210,7 +9281,7 @@ function captureLkgSlot(args) {
   if (!built)
     return false;
   const modelKeys = canonicalLkgModelKeys(args.modelKey, args.providerKey);
-  return captureSlot(args.sessionId, {
+  const slot = {
     jsonPrefix: built.jsonPrefix,
     inputIdSeq: built.inputIdSeq,
     inputContentDigests: built.inputContentDigests,
@@ -9218,7 +9289,17 @@ function captureLkgSlot(args) {
     modelKey: modelKeys.modelKey,
     providerKey: modelKeys.providerKey,
     capturedAt: args.capturedAt ?? Date.now()
-  });
+  };
+  const captured = captureSlot(args.sessionId, slot);
+  if (captured)
+    noteCapturedLkgRequest({
+      sessionId: args.sessionId,
+      slot,
+      request: built.anchorIndex === args.input.length - 1 ? claimLkgRequestIdentity(args.sessionId) : undefined,
+      systemPromptTokens: args.systemPromptTokens ?? 0,
+      agentName: args.agentName
+    });
+  return captured;
 }
 function entryIdsAreValid(slot, entryIds) {
   if (slot.inputIdSeq.length === 0 || entryIds.length < slot.inputIdSeq.length)
@@ -9444,6 +9525,45 @@ function replayLkg(args) {
   return { ok: true, messages: replayed };
 }
 
+// src/hooks/magic-context/lkg-replay-fit.ts
+var RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
+function lkgReplayLimit(args) {
+  const { db, sessionId, model } = args;
+  const trusted = model ? resolveTrustedContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : undefined;
+  if (trusted !== undefined && trusted > 0)
+    return trusted;
+  const detected = getOverflowState(db, sessionId, args.modelKey).detectedContextLimit;
+  return detected > 0 ? detected : undefined;
+}
+function measureLkgReplay(args) {
+  const baseline = args.measuredInputTokens ?? 0;
+  const tailLimit = Math.max(0, args.limit - baseline);
+  const proxy = wireContentBytes(args.messages, tailLimit * RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN, RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+  const skipped = { proxy, estimatorRan: false, trusted: false };
+  if (proxy === null)
+    return { fit: "unproven", tokens: null, ...skipped };
+  const proxyTokens = baseline + Math.ceil(proxy.bytes / RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+  if (proxy.aborted || proxyTokens > args.limit) {
+    return { fit: "over", tokens: null, proxyTokens, ...skipped };
+  }
+  let estimate;
+  try {
+    estimate = args.estimate();
+  } catch {
+    return { fit: "unproven", tokens: null, ...skipped };
+  }
+  const seen = { proxy, estimatorRan: true, trusted: estimate.trusted };
+  const tokens = baseline + estimate.tokens;
+  if (!estimate.trusted || !Number.isFinite(tokens) || tokens <= 0 || estimate.tokens < 0) {
+    return {
+      fit: "unproven",
+      tokens: Number.isFinite(estimate.tokens) ? estimate.tokens : null,
+      ...seen
+    };
+  }
+  return tokens > args.limit ? { fit: "over", tokens, proxyTokens, ...seen } : { fit: "under", tokens, ...seen };
+}
+
 // src/hooks/magic-context/storage-busy-refusal.ts
 var STORAGE_BUSY_MESSAGE = "Magic Context's database is busy (another process held it too long); send your message again.";
 function describeStorageBusyCause(cause) {
@@ -9471,7 +9591,7 @@ class StorageBusyRefusalError extends Error {
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } 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
@@ -9712,7 +9832,7 @@ function createSystemPromptHashHandler(deps) {
     }
     const stickyDate = stickyDateBySession.get(sessionId);
     const stableCandidate = currentDate && stickyDate && currentDate !== stickyDate ? liveSystemContent.replace(DATE_PATTERN_ALL, stickyDate) : liveSystemContent;
-    const stableCandidateHash = createHash4("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = createHash5("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const dateMayAdvance = isCacheBusting || idleCacheExpired || contentOrPresetChanged;
     if (currentDate && !stickyDate) {
@@ -9732,7 +9852,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash4("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = createHash5("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -9947,10 +10067,14 @@ function recordSessionProjectIdentity(db, sessionId, projectPath) {
     return;
   const harness = getHarness();
   const now = Date.now();
+  let previousProjectPath;
   db.transaction(() => {
+    const existing = db.prepare("SELECT project_path FROM session_projects WHERE session_id = ? AND harness = ?").get(sessionId, harness);
+    previousProjectPath = existing?.project_path;
     getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
     getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath, SESSION_CHUNK_REPAIR_BATCH_SIZE);
   }).immediate();
+  return previousProjectPath === projectPath ? undefined : { previousProjectPath, projectPath };
 }
 function hasRecordedSessionProjectIdentity(db, sessionId) {
   const row = db.prepare("SELECT 1 AS found FROM session_projects WHERE session_id = ? AND harness = ?").get(sessionId, getHarness());
@@ -10384,6 +10508,29 @@ function commitCompactionModeRecord(db, sessionId, record) {
   setCompactionModeRecord(db, sessionId, record);
 }
 
+// src/hooks/magic-context/historian-drain-gate.ts
+var loggedWindows = new WeakMap;
+function isHistorianDrainBudgetSpent(args) {
+  const target = deriveProtectedTailTokenTarget(args);
+  const state = getProtectedTailDrainBudgetSkip({
+    ...args,
+    usable: target.usable,
+    perRunCap: selectPerRunCap({ ...args, N: target.N })
+  });
+  if (!state)
+    return false;
+  let windows = loggedWindows.get(args.db);
+  if (!windows) {
+    windows = new Map;
+    loggedWindows.set(args.db, windows);
+  }
+  if (windows.get(args.sessionId) !== state.resetsAt) {
+    windows.set(args.sessionId, state.resetsAt);
+    sessionLog(args.sessionId, `historian skip: internal drain budget spent (${state.spentTokens}/${state.limitTokens} tokens); next eligible at ${new Date(state.nextEligibleAt).toISOString()}`);
+  }
+  return true;
+}
+
 // src/features/magic-context/storage-reasoning-removal.ts
 var NAMESPACE2 = "reasoningRemoval";
 var BACKUP_NAMESPACE = "reasoningRemovalBackup";
@@ -11375,7 +11522,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         taggerFloor,
         storedTotalsExcludeToolTags
       });
-      const hasProtectedEligibleHead = boundary.offset < boundary.protectedTailStart;
+      const hasProtectedEligibleHead = boundary.offset < Math.min(boundary.protectedTailStart, boundary.eligibleEndOrdinal);
       if (!hasProtectedEligibleHead) {
         return {
           ...TAIL_INFO_DEFAULTS,
@@ -11387,7 +11534,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
       const seed = sessionDecisionCalibration(db, sessionId);
       const sourceRatio = Math.max(seed.proseRatio, seed.toolsRatio);
       const scanBudget = Math.floor(Math.max(MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE, triggerBudget * TAIL_SIZE_TRIGGER_MULTIPLIER) / sourceRatio);
-      const chunk = readSessionChunk2(sessionId, scanBudget, rawEligibility.offset, boundary.protectedTailStart);
+      const chunk = readSessionChunk2(sessionId, scanBudget, rawEligibility.offset, boundary.eligibleEndOrdinal);
       const isMeaningful = chunk.hasMore || boundary.trueRawEligibleTokens >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || Math.ceil(chunk.tokenEstimate * sourceRatio) >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || chunk.messageCount >= MIN_PROACTIVE_TAIL_MESSAGE_COUNT;
       return {
         nextStartOrdinal: rawEligibility.offset,
@@ -11414,6 +11561,14 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
   }
+  if (isHistorianDrainBudgetSpent({
+    db,
+    sessionId,
+    usagePercentage: usage.percentage,
+    contextLimit: resolveBoundaryContextLimit(usage, contextLimit),
+    executeThresholdPercentage
+  }))
+    return { shouldFire: false };
   const lazyInMemoryTail = typeof inMemoryTail === "function" ? inMemoryTail : undefined;
   let resolvedInMemoryTail = typeof inMemoryTail === "function" ? undefined : inMemoryTail;
   if (resolvedInMemoryTail) {
@@ -11927,8 +12082,24 @@ function historianJoinFailClosedMessage(input) {
   return `historian did not complete within ${seconds} s: ${reason}`;
 }
 function runCompartmentPhase(args) {
+  if (args.historianRunnable !== false && !args.compactionOff && args.canRunCompartments && !getActiveCompartmentRun(args.sessionId) && (args.sessionMeta.compartmentInProgress || args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE) && isHistorianDrainBudgetSpent({
+    db: args.db,
+    sessionId: args.sessionId,
+    contextLimit: args.boundaryContextLimit,
+    executeThresholdPercentage: args.boundaryExecuteThresholdPercentage,
+    usagePercentage: args.boundaryUsage.percentage
+  })) {
+    if (args.sessionMeta.compartmentInProgress) {
+      updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
+    }
+    return runCompartmentPhaseImpl({
+      ...args,
+      canRunCompartments: false,
+      sessionMeta: { compartmentInProgress: false }
+    });
+  }
   const historianRunnable = args.historianRunnable !== false;
-  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && (args.sessionMeta.compartmentInProgress || args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE);
+  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE;
   if (!willReadRawHistory) {
     return runCompartmentPhaseImpl(args);
   }
@@ -12054,7 +12225,7 @@ async function runCompartmentPhaseImpl(args) {
     compartmentInProgress = false;
   }
   if (historianRunnable && args.canRunCompartments && args.sessionMeta.compartmentInProgress && !getActiveCompartmentRun(args.sessionId)) {
-    if (!hasEligibleHistoryForCompartment()) {
+    if (args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE && !hasEligibleHistoryForCompartment()) {
       sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
       updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
       compartmentInProgress = false;
@@ -12071,7 +12242,7 @@ async function runCompartmentPhaseImpl(args) {
         db: args.db,
         sessionId: args.sessionId,
         historianChunkTokens: args.historianChunkTokens,
-        boundarySnapshot: getBoundarySnapshotForCompartment() ?? undefined,
+        boundarySnapshot: args.preResolvedBoundarySnapshot,
         currentContextLimit: args.boundaryContextLimit,
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
@@ -12089,6 +12260,12 @@ async function runCompartmentPhaseImpl(args) {
         autoPromote: args.autoPromote,
         onCompartmentStatePublished: args.onCompartmentStatePublished,
         preserveInjectionCacheUntilConsumed: true
+      }, undefined, () => {
+        const snapshot = getBoundarySnapshotForCompartment();
+        if (snapshot && hasRunnableCompartmentWindow(snapshot))
+          return snapshot;
+        sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
+        return null;
       });
       compartmentInProgress = true;
     }
@@ -15833,19 +16010,33 @@ function createTransform(deps) {
       if (false) {}
       return false;
     };
-    const startRecoveryRun = () => {
-      const scale = emergencyUsagePercentageEarly >= 95 ? 0.25 : 0.5;
-      let boundarySnapshot = getRunnableBoundaryForCompartment();
-      if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
-        boundarySnapshot = getRunnableBoundaryForCompartment(scale);
-      }
-      if (false) {}
-      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || !boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+    const startRecoveryRun = (onReady) => {
+      if (isHistorianDrainBudgetSpent({
+        db,
+        sessionId,
+        contextLimit: boundaryContextLimit,
+        executeThresholdPercentage: boundaryExecuteThreshold,
+        usagePercentage: boundaryUsageForProtectedTail.percentage
+      }))
         return false;
-      }
-      if (getActiveCompartmentRun(sessionId)) {
+      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || getActiveCompartmentRun(sessionId))
+        return false;
+      const prepareRecoveryBoundary = () => {
+        const scale = emergencyUsagePercentageEarly >= 95 ? 0.25 : 0.5;
+        let boundarySnapshot = getRunnableBoundaryForCompartment();
+        if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+          boundarySnapshot = getRunnableBoundaryForCompartment(scale);
+        }
+        if (false) {}
+        if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot))
+          return null;
+        onReady?.();
+        return boundarySnapshot;
+      };
+      const urgent = emergencyUsagePercentageEarly >= 95;
+      const boundarySnapshot = urgent ? prepareRecoveryBoundary() : undefined;
+      if (urgent && !boundarySnapshot)
         return false;
-      }
       updateSessionMeta(db, sessionId, { compartmentInProgress: true });
       startCompartmentAgent({
         client: deps.client,
@@ -15854,7 +16045,7 @@ function createTransform(deps) {
         db,
         sessionId,
         historianChunkTokens: historianRun?.chunkTokens ?? deps.getHistorianChunkTokens?.() ?? 20000,
-        boundarySnapshot,
+        boundarySnapshot: boundarySnapshot ?? undefined,
         currentContextLimit: boundaryContextLimit,
         historyBudgetTokens,
         historianTimeoutMs: historianRun?.timeoutMs ?? deps.historianTimeoutMs,
@@ -15874,7 +16065,7 @@ function createTransform(deps) {
           deferredHistoryRefreshSessions.add(sid);
           deferredMaterializationSessions.add(sid);
         }
-      });
+      }, undefined, urgent ? undefined : prepareRecoveryBoundary);
       return true;
     };
     if (fullFeatureMode && !compactionOff && historianFailureState.failureCount > 0 && emergencyUsagePercentageEarly >= 95 && !recoveryNoHeadEscapeActive) {
@@ -15888,13 +16079,15 @@ function createTransform(deps) {
         sessionLog(sessionId, "transform: emergency recovery remains armed — no complete eligible head before protected tail");
       }
       sessionLog(sessionId, `EMERGENCY: historian recovery requested at ${emergencyPercentage}%, failures: ${historianFailureState.failureCount}`);
-    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0 && getEligibleHistoryForCompartment() && startRecoveryRun()) {
-      sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
-      if (deps.client) {
-        withoutSqliteTransformPass(() => sendStatusNotification2(deps.client, sessionId, `## Historian recovery
+    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0) {
+      startRecoveryRun(() => {
+        sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
+        if (deps.client) {
+          withoutSqliteTransformPass(() => sendStatusNotification2(deps.client, sessionId, `## Historian recovery
 
 Historian previously failed ${historianFailureState.failureCount} time(s), so Magic Context is retrying history comparting immediately after restart.`, notificationParams));
-      }
+        }
+      });
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
     const memoryProjectDirectory = compartmentDirectory || process.cwd();
@@ -16441,7 +16634,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         input: lkgInput,
         output: messages,
         modelKey,
-        providerKey
+        providerKey,
+        systemPromptTokens: sessionMeta.systemPromptTokens,
+        agentName: notificationParams?.agent
       });
       if (captured) {
         const capturedSlot = getInMemorySlot(sessionId);
@@ -17855,8 +18050,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-3qxeqwb9.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-y29y9fsr.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-vc5dkzy2.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-rnc4nrsr.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -17905,7 +18100,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await import("./wrapup-orchestrator-wgb2nd19.js");
+    const { runManagedWrapup } = await import("./wrapup-orchestrator-x9xamts2.js");
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -18646,7 +18841,8 @@ function hostUsesMediaAssets() {
   schemaUsesAssets.set(messageClass, uses);
   return uses;
 }
-function decodeThroughHostSchema(source) {
+function decodeThroughHostSchema(encoded) {
+  const source = encoded.source;
   const messageClass = rememberedMessageClass;
   if (!messageClass)
     return "no host message class seen";
@@ -18666,7 +18862,7 @@ function decodeThroughHostSchema(source) {
   const run = decode?.run;
   if (typeof run !== "function")
     return "host media schema has no decode transformation";
-  const result = run.call(decode, { _tag: "Some", value: { source } }, {});
+  const result = run.call(decode, { _tag: "Some", value: encoded }, {});
   const option = result?._tag === "Success" ? result.value : undefined;
   const asset = option?._tag === "Some" ? option.value : undefined;
   if (!isClassInstance(asset) || asset.source !== source)
@@ -18674,18 +18870,30 @@ function decodeThroughHostSchema(source) {
   return asset;
 }
 function hostMediaAsset(data, mediaType) {
-  const source = { type: "base64", data, mediaType };
+  return hostMediaFromEncoded({ source: { type: "base64", data, mediaType } });
+}
+function hostMediaFromEncoded(value) {
+  if (!isRecord3(value.source))
+    return "missing Media.Asset source";
+  const encoded = structuredClone(value);
+  if (encoded.source.type === "bytes") {
+    if (typeof encoded.source.data !== "string")
+      return "bytes media has no JSON codec payload";
+    encoded.source.data = new Uint8Array(Buffer.from(encoded.source.data, "base64"));
+  }
+  if (!["bytes", "base64", "url", "ref"].includes(String(encoded.source.type)))
+    return "unknown Media.Asset source";
   let first = "no Media.Asset seen in this process";
   if (rememberedAssetClass) {
     try {
-      return new rememberedAssetClass({ source });
+      return new rememberedAssetClass(encoded);
     } catch (error) {
       first = `remembered asset class threw: ${String(error)}`;
     }
   }
   let second;
   try {
-    const decoded = decodeThroughHostSchema(source);
+    const decoded = decodeThroughHostSchema(encoded);
     if (typeof decoded !== "string")
       return decoded;
     second = decoded;
@@ -18703,9 +18911,12 @@ var v2CompactionMarkerStrategy = {
   reconcile: () => false
 };
 
+// src/v2/fold/memory-cache.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
 // src/v2/fold/owner.ts
-import { createHash as createHash5 } from "node:crypto";
-var foldDigest = (value) => createHash5("sha256").update(value).digest("hex");
+import { createHash as createHash6 } from "node:crypto";
+var foldDigest = (value) => createHash6("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -18785,78 +18996,693 @@ class FoldOwner {
   }
 }
 
-// src/v2/fold/restore.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+// src/v2/fold/memory-cache.ts
+var DEFAULT_NATIVE_FOLD_BUDGET = Object.freeze({
+  maxSessionBytes: 16 * 1024 * 1024,
+  maxSessions: 16
+});
+var stringBytes = (value) => (value?.length ?? 0) * 2;
+
+class NativeFoldCache {
+  resolveDB;
+  sourceID = randomUUID2();
+  tails = new Map;
+  nativeRows = new Map;
+  admissions = new Map;
+  retention = new Map;
+  evictionListeners = new Set;
+  budget;
+  constructor(resolveDB, budget = DEFAULT_NATIVE_FOLD_BUDGET) {
+    this.resolveDB = resolveDB;
+    if (!Number.isSafeInteger(budget.maxSessionBytes) || budget.maxSessionBytes < 1 || !Number.isSafeInteger(budget.maxSessions) || budget.maxSessions < 1)
+      throw new Error("Native fold cache budgets must be positive integers");
+    this.budget = { ...budget };
+  }
+  onEvict(listener) {
+    this.evictionListeners.add(listener);
+  }
+  touch(sessionID) {
+    const state = this.retention.get(sessionID) ?? { active: 0, bytes: 0, replayBytes: 0 };
+    this.retention.delete(sessionID);
+    this.retention.set(sessionID, state);
+    return state;
+  }
+  hold(sessionID) {
+    const state = this.touch(sessionID);
+    state.active++;
+    return () => {
+      state.active--;
+      this.enforceBudget();
+    };
+  }
+  accountReplay(sessionID, bytes) {
+    this.touch(sessionID).replayBytes = bytes;
+    this.recount(sessionID);
+  }
+  usage() {
+    return {
+      sessions: this.retention.size,
+      bytes: [...this.retention.values()].reduce((total, state) => total + state.bytes, 0)
+    };
+  }
+  recount(sessionID) {
+    const state = this.touch(sessionID);
+    let bytes = 256 + stringBytes(sessionID) + state.replayBytes;
+    const tail = this.tails.get(sessionID);
+    if (tail)
+      bytes += 128 + stringBytes(tail.data) + stringBytes(tail.digest);
+    for (const row of this.nativeRows.get(sessionID)?.values() ?? [])
+      bytes += 256 + stringBytes(row.id) + stringBytes(row.type) + stringBytes(row.data) + stringBytes(row.digest);
+    for (const row of this.admissions.get(sessionID)?.values() ?? [])
+      bytes += 256 + stringBytes(row.admission_id) + stringBytes(row.status) + stringBytes(row.owner_token) + stringBytes(row.data) + stringBytes(row.payload) + stringBytes(row.digest);
+    state.bytes = bytes;
+    this.enforceBudget();
+  }
+  enforceBudget() {
+    for (const [id, state] of this.retention)
+      if (!state.active && state.bytes > this.budget.maxSessionBytes)
+        this.evict(id);
+    for (const [id, state] of this.retention) {
+      if (this.retention.size <= this.budget.maxSessions)
+        break;
+      if (!state.active)
+        this.evict(id);
+    }
+  }
+  evict(sessionID) {
+    this.tails.delete(sessionID);
+    this.nativeRows.delete(sessionID);
+    this.admissions.delete(sessionID);
+    this.retention.delete(sessionID);
+    for (const listener of this.evictionListeners)
+      listener(sessionID);
+  }
+  get db() {
+    return this.resolveDB();
+  }
+  tail(sessionID) {
+    const record = this.tails.get(sessionID);
+    if (record)
+      this.touch(sessionID);
+    return record && { ...record };
+  }
+  async saveTail(sessionID, data, rows) {
+    this.tails.set(sessionID, {
+      revision: (this.tails.get(sessionID)?.revision ?? -1) + 1,
+      data,
+      digest: foldDigest(data)
+    });
+    const kept = this.nativeRows.get(sessionID) ?? new Map;
+    for (const row of rows)
+      kept.set(row.id, Object.freeze({ ...row, revision: (kept.get(row.id)?.revision ?? -1) + 1 }));
+    this.nativeRows.set(sessionID, kept);
+    this.recount(sessionID);
+  }
+  replaceRows(sessionID, through, rows, after = -1) {
+    const kept = this.nativeRows.get(sessionID) ?? new Map;
+    for (const [id, row] of kept)
+      if (row.seq > after && row.seq <= through)
+        kept.delete(id);
+    for (const row of rows)
+      kept.set(row.id, Object.freeze({ ...row, revision: 0 }));
+    this.nativeRows.set(sessionID, kept);
+    this.recount(sessionID);
+  }
+  truncate(sessionID, through) {
+    const kept = this.nativeRows.get(sessionID);
+    if (kept) {
+      for (const [id, row] of kept)
+        if (row.seq > through)
+          kept.delete(id);
+    }
+    if (kept)
+      this.recount(sessionID);
+  }
+  sequenceForID(sessionID, id) {
+    return this.nativeRows.get(sessionID)?.get(id)?.seq;
+  }
+  containsRows(sessionID, ids) {
+    const kept = this.nativeRows.get(sessionID);
+    return ids.every((id) => kept?.has(id));
+  }
+  rows(sessionID, after, through) {
+    if (this.retention.has(sessionID))
+      this.touch(sessionID);
+    return [...this.nativeRows.get(sessionID)?.values() ?? []].filter((row) => row.seq > after && row.seq <= through).sort((a, b) => a.seq - b.seq).map((row) => ({ ...row }));
+  }
+  admission(sessionID, id) {
+    const record = this.admissions.get(sessionID)?.get(id);
+    if (record)
+      this.touch(sessionID);
+    return record && { ...record };
+  }
+  put(sessionID, id, record) {
+    const kept = this.admissions.get(sessionID) ?? new Map;
+    kept.set(id, Object.freeze({ ...record }));
+    this.admissions.set(sessionID, kept);
+    this.recount(sessionID);
+  }
+  async supply(sessionID, id, payload) {
+    const old = this.admission(sessionID, id);
+    this.put(sessionID, id, {
+      admission_id: id,
+      revision: (old?.revision ?? -1) + 1,
+      status: old?.status ?? "supplied",
+      owner_token: old?.owner_token ?? null,
+      data: old?.data ?? "{}",
+      payload,
+      digest: foldDigest(payload),
+      logged_at: old?.logged_at ?? null
+    });
+  }
+  latestAttempt(sessionID) {
+    const record = [...this.admissions.get(sessionID)?.values() ?? []].reverse().find((row) => JSON.parse(row.data).after !== undefined);
+    return record && { ...record };
+  }
+  async claim(sessionID, id, data, owner, _now) {
+    const old = this.admission(sessionID, id);
+    if (old?.owner_token || old?.logged_at !== null && old?.logged_at !== undefined)
+      return false;
+    this.put(sessionID, id, {
+      admission_id: id,
+      revision: 0,
+      status: "pending",
+      owner_token: owner,
+      data,
+      payload: old?.payload ?? null,
+      digest: old?.digest ?? null,
+      logged_at: null
+    });
+    return true;
+  }
+  async finish(sessionID, id, owner, status, now) {
+    const old = this.admission(sessionID, id);
+    if (!old || old.owner_token !== owner || old.status !== "pending")
+      return false;
+    this.put(sessionID, id, { ...old, status, owner_token: null, logged_at: now });
+    return true;
+  }
+  async forget(sessionID) {
+    this.evict(sessionID);
+  }
+}
+function nativeFoldCache(db, budget) {
+  return new NativeFoldCache(typeof db === "function" ? db : () => db, budget);
+}
 
-// src/v2/hooks/storage-notice.ts
-var STORAGE_NOTICE_PREFIX = "[Magic Context storage notice] ";
-function formatStorageRefusalNotice(reason) {
-  return `${STORAGE_NOTICE_PREFIX}This turn was not sent to the model. ${formatFailClosedBlockingSummary(reason)}`;
+// src/v2/tool-result.ts
+function isToolError(part) {
+  const result = part.result;
+  return part.resultType === "error" || result?.type === "error" || result !== null && typeof result === "object" && "error" in result;
 }
-function formatStorageRecoveryNotice(hiddenWorkRecovered) {
-  return hiddenWorkRecovered ? `${STORAGE_NOTICE_PREFIX}Magic Context storage is available again and turns are sent to the model. The historian and dreamer are running again. Restart OpenCode to enable Magic Context's tools.` : `${STORAGE_NOTICE_PREFIX}Magic Context storage is available again and turns are sent to the model. Restart OpenCode to enable Magic Context's tools, historian and dreamer.`;
+function toolErrorText(result) {
+  const value = result.value === undefined ? result : result.value;
+  return typeof value === "string" ? value : JSON.stringify(value);
 }
-function isStorageNoticeText(text) {
-  return typeof text === "string" && text.startsWith(STORAGE_NOTICE_PREFIX);
+function toolStateContent(state) {
+  if (typeof state.output === "string")
+    return state.output;
+  if (state.status === "error")
+    return toolErrorText({ error: state.error, content: state.content ?? [] });
+  if (typeof state.content === "string")
+    return state.content;
+  if (!Array.isArray(state.content))
+    return "";
+  return state.content.map((part) => {
+    if (typeof part === "string")
+      return part;
+    if (!part || typeof part !== "object")
+      return "";
+    const value = part;
+    if (typeof value.text === "string")
+      return value.text;
+    if (typeof value.value === "string")
+      return value.value;
+    return "";
+  }).filter(Boolean).join(`
+`);
 }
-function hasStorageNoticeShape(message) {
-  if (message.role !== "user" || typeof message.id !== "string")
-    return false;
-  if (message.content.length !== 1)
+
+// src/v2/hooks/payload.ts
+var HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
+var HOST_CONTENT_TYPES = new Set([
+  "text",
+  "media",
+  "tool-call",
+  "tool-result",
+  "reasoning",
+  "compaction",
+  "effort"
+]);
+function rejectContentPart(message, part, reason) {
+  const type = typeof part.type === "string" ? part.type : "<missing>";
+  const text = `v2 context omitted a content part the host would reject: type=${type} message=${String(message.info.id ?? "<head>")} reason=${reason}`;
+  if (typeof message.info.sessionID === "string")
+    sessionLog(message.info.sessionID, text);
+  else
+    log(text);
+}
+function isHostInstance(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
-  const part = message.content[0];
-  return part?.type === "text" && isStorageNoticeText(part.text);
+  const prototype = Object.getPrototypeOf(value);
+  return prototype !== Object.prototype && prototype !== null;
 }
-async function dropStorageNotices(messages, isAdmittedSynthetic) {
-  const drop = new Set;
-  for (const message of messages) {
-    if (!hasStorageNoticeShape(message))
-      continue;
-    if (await isAdmittedSynthetic(message.id))
-      drop.add(message);
-  }
-  if (drop.size === 0)
-    return 0;
-  const kept = messages.filter((message) => !drop.has(message));
-  messages.splice(0, messages.length, ...kept);
-  return drop.size;
+function containsHostInstance(value) {
+  if (isHostInstance(value))
+    return true;
+  if (Array.isArray(value))
+    return value.some(containsHostInstance);
+  if (value && typeof value === "object")
+    return Object.values(value).some(containsHostInstance);
+  return false;
 }
-
-// src/v2/fold/restore.ts
-function unavailableAttachmentNote(name, mediaType) {
-  return `[Attachment ${name ? `"${name}" ` : ""}(${mediaType}) is not available in this restored history]`;
+function clonePreservingInstances(value) {
+  if (isHostInstance(value))
+    return value;
+  if (Array.isArray(value))
+    return value.map(clonePreservingInstances);
+  if (value && typeof value === "object") {
+    const copy = {};
+    for (const [key, entry] of Object.entries(value))
+      copy[key] = clonePreservingInstances(entry);
+    return copy;
+  }
+  return value;
 }
-var imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-function attachmentParts(files, rowID, media) {
-  const seen = new Map;
-  return files.flatMap((file) => {
-    if (imageMimes.has(file.mime) && file.source.type === "inline" && file.mention?.text) {
-      const key = JSON.stringify([
-        file.mime,
-        file.name ?? null,
-        file.description ?? null,
-        file.mention.text
-      ]);
-      const payloads = seen.get(key) ?? new Set;
-      if (payloads.has(file.data))
-        return [];
-      payloads.add(file.data);
-      seen.set(key, payloads);
+function contentKey(value) {
+  const plain = (entry) => {
+    if (ArrayBuffer.isView(entry)) {
+      return {
+        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
+      };
     }
-    const uri = file.source.type === "uri" ? file.source.uri : undefined;
-    const location = uri?.startsWith("file:") ? fileURLToPath2(uri) : undefined;
-    if (file.mime === "text/plain" || file.mime === "application/x-directory") {
-      const directory = file.mime === "application/x-directory";
-      return [
-        {
-          type: "text",
-          text: `
-
-${[
-            directory ? `Attached directory: ${location ?? file.name ?? uri ?? "directory"}` : `Attached file: ${file.name ?? uri ?? "inline attachment"}`,
-            file.description === undefined ? undefined : `Description: ${file.description}`,
-            directory && !file.data.length ? undefined : "",
-            directory && !file.data.length ? undefined : Buffer.from(file.data, "base64").toString("utf8")
+    if (Array.isArray(entry))
+      return entry.map(plain);
+    if (entry && typeof entry === "object") {
+      return Object.fromEntries(Object.entries(entry).map(([key, nested]) => [key, plain(nested)]));
+    }
+    return entry;
+  };
+  return JSON.stringify(plain(value));
+}
+function fileContentValue(result) {
+  const value = result?.value;
+  if (result?.type !== "content" || !Array.isArray(value))
+    return;
+  return value.some((item) => item?.type === "file") ? value : undefined;
+}
+function contentValueText(value) {
+  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
+`);
+}
+function contentValueAttachments(value) {
+  return value.filter((item) => item?.type === "file").map((item) => ({
+    type: "file",
+    mime: item.mime,
+    url: item.uri,
+    ...typeof item.name === "string" ? { filename: item.name } : {}
+  }));
+}
+function rebuildFileContent(value, output) {
+  if (isDroppedToolOutput(output))
+    return { type: "text", value: output };
+  const rebuilt = [];
+  let placed = false;
+  for (const item of value) {
+    if (item?.type !== "text") {
+      rebuilt.push(item);
+      continue;
+    }
+    if (placed)
+      continue;
+    placed = true;
+    rebuilt.push({ ...item, text: output });
+  }
+  if (!placed && output)
+    rebuilt.unshift({ type: "text", text: output });
+  return { type: "content", value: rebuilt };
+}
+function adaptPayload(draft, admittedIDs = new Set) {
+  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;
+  const hostParts = new Map;
+  const hostPartTypes = new Set;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
+        const key = contentKey(part);
+        if (!hostParts.has(key))
+          hostParts.set(key, part);
+        hostPartTypes.add(part.type);
+      }
+      if (part.type === "tool-result" && typeof part.id === "string") {
+        const queue = results.get(part.id) ?? [];
+        queue.push({ part, message });
+        results.set(part.id, queue);
+      }
+    }
+  }
+  const paired = new Set;
+  const bridges = new Map;
+  const originals = new Map;
+  const bridgesByMessageID = new Map;
+  const bridgesByCarrier = new Map;
+  const originalsByID = new Map;
+  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
+  const nativeTool = (call, result) => {
+    const hostResult = result?.part.result;
+    const failed = result !== undefined && isToolError(result.part);
+    const value = hostResult?.value;
+    const files = fileContentValue(hostResult);
+    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
+    const part = {
+      type: "tool",
+      callID: call?.id ?? result?.part.id,
+      tool: call?.name ?? result?.part.name,
+      state: {
+        input: structuredClone(call?.input ?? {}),
+        status: failed ? "error" : result ? "completed" : "running",
+        ...result ? { output } : {},
+        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
+        ...files ? { attachments: contentValueAttachments(files) } : {}
+      }
+    };
+    bridges.set(part, {
+      call,
+      result: result?.part,
+      resultMessage: result?.message,
+      output,
+      files
+    });
+    if (result)
+      paired.add(result.part);
+    return part;
+  };
+  const convertedTool = (source) => {
+    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
+    const output = toolStateContent(sourceState);
+    const { content: _content, ...projectedState } = structuredClone(sourceState);
+    const part = {
+      type: "tool",
+      callID: source.callID ?? source.id,
+      tool: source.tool ?? source.name,
+      state: { ...projectedState, output }
+    };
+    bridges.set(part, { native: source, output });
+    return part;
+  };
+  const callParts = new Map;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type === "tool-call") {
+        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
+      } else if (part.type === "tool") {
+        callParts.set(part, convertedTool(part));
+      }
+    }
+  }
+  const messages = [];
+  for (const message of source) {
+    const parts = [];
+    for (const content of message.content) {
+      if (paired.has(content))
+        continue;
+      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
+      if (message.id && admittedIDs.has(message.id))
+        part.synthetic = true;
+      parts.push(part);
+    }
+    if (!parts.length && message.content.length)
+      continue;
+    const byCallID = new Map;
+    for (const part of parts) {
+      const bridge = bridges.get(part);
+      if (bridge && typeof part.callID === "string")
+        byCallID.set(part.callID, bridge);
+    }
+    if (typeof message.id === "string") {
+      bridgesByMessageID.set(message.id, byCallID);
+      originalsByID.set(message.id, message);
+    }
+    const mapped = {
+      info: {
+        id: message.id,
+        sessionID: draft.sessionID,
+        role: message.role,
+        ...{
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agent: draft.agent
+        }
+      },
+      parts
+    };
+    originals.set(mapped, message);
+    if (typeof message.id !== "string")
+      bridgesByCarrier.set(mapped, byCallID);
+    messages.push(mapped);
+  }
+  return {
+    messages,
+    commit() {
+      let head = 0;
+      const rendered = [];
+      for (const message of messages) {
+        const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
+        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
+        const content = [];
+        const following = [];
+        for (const candidate of message.parts) {
+          const part = candidate;
+          const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
+          if (!bridge) {
+            if (part.type === "tool") {
+              const state = part.state;
+              if (typeof part.callID !== "string" || typeof part.tool !== "string" || !state || typeof state !== "object") {
+                rejectContentPart(message, part, "tool has no call ID, name, or state");
+                continue;
+              }
+              content.push({
+                type: "tool-call",
+                id: part.callID,
+                name: part.tool,
+                input: state.input
+              });
+              if (state.status === "completed" || state.status === "error") {
+                following.push({
+                  role: "tool",
+                  content: [
+                    {
+                      type: "tool-result",
+                      id: part.callID,
+                      name: part.tool,
+                      result: {
+                        type: state.status === "error" ? "error" : "text",
+                        value: toolStateContent(state)
+                      }
+                    }
+                  ]
+                });
+              }
+              continue;
+            }
+            if (part.type === "file") {
+              const mime = part.mime;
+              const url = part.url;
+              const prefix = `data:${mime};base64,`;
+              if (typeof mime !== "string" || !/^image\/(png|jpeg|gif|webp)$/.test(mime) || typeof url !== "string" || !url.startsWith(prefix)) {
+                rejectContentPart(message, part, "file is not an inline supported image");
+                continue;
+              }
+              const asset = hostMediaAsset(url.slice(prefix.length), mime);
+              if (typeof asset === "string") {
+                rejectContentPart(message, part, `host media unavailable: ${asset}`);
+                continue;
+              }
+              content.push({ type: "media", media: asset });
+              continue;
+            }
+            if (!HOST_CONTENT_TYPES.has(String(part.type))) {
+              rejectContentPart(message, part, "unknown host content type");
+              continue;
+            }
+            const { synthetic: _synthetic, ...clean } = part;
+            const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
+            content.push(original ?? clean);
+            continue;
+          }
+          const state = part.state;
+          if (bridge.native) {
+            const native = bridge.native;
+            const callID = String(native.id ?? native.callID ?? part.callID);
+            const name = String(native.name ?? native.tool ?? part.tool);
+            content.push({ type: "tool-call", id: callID, name, input: state.input });
+            if (state.status === "completed" || state.status === "error") {
+              following.push({
+                role: "tool",
+                content: [
+                  {
+                    type: "tool-result",
+                    id: callID,
+                    name,
+                    result: {
+                      type: state.status === "error" ? "error" : "text",
+                      value: state.output
+                    }
+                  }
+                ]
+              });
+            }
+            continue;
+          }
+          if (bridge.call)
+            content.push({ ...bridge.call, input: state.input });
+          if (bridge.result && bridge.resultMessage) {
+            const result = {
+              ...bridge.result,
+              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
+                type: state.status === "error" ? "error" : "text",
+                value: state.output
+              }
+            };
+            if (bridge.resultMessage === original)
+              content.push(result);
+            else
+              following.push({ ...bridge.resultMessage, content: [result] });
+          }
+        }
+        if (content.length || !original?.content.length) {
+          const value = {
+            ...original,
+            id,
+            role: message.info.role ?? "user",
+            content
+          };
+          const existing = id ? existingHeads.get(id) : undefined;
+          rendered.push(existing ? Object.assign(existing, { content }) : value);
+        }
+        rendered.push(...following);
+      }
+      draft.messages.splice(0, draft.messages.length, ...rendered);
+    }
+  };
+}
+
+// src/v2/fold/native-codec.ts
+class NativeReplayUnavailable extends Error {
+}
+function encodeNative(messages) {
+  for (const message of messages)
+    for (const part of message.content) {
+      if (part.type !== "media" || !part.media)
+        continue;
+      const asset = part.media;
+      if (typeof asset.toJSON !== "function" || asset.headers !== undefined)
+        throw new NativeReplayUnavailable("Native media has no lossless replay codec");
+      const encoded = asset.toJSON();
+      const revived = hostMediaFromEncoded(encoded);
+      if (typeof revived === "string" || JSON.stringify(revived) !== JSON.stringify(asset))
+        throw new NativeReplayUnavailable("Native media cannot be decoded losslessly before admission");
+    }
+  const encoded = JSON.parse(JSON.stringify(messages));
+  const freeze = (value) => {
+    if (!value || typeof value !== "object")
+      return;
+    for (const item of Object.values(value))
+      freeze(item);
+    Object.freeze(value);
+  };
+  freeze(encoded);
+  return encoded;
+}
+function reviveNative(messages) {
+  const result = structuredClone([...messages]);
+  for (const message of result)
+    for (const part of message.content) {
+      if (part.type !== "media" || !part.media)
+        continue;
+      const asset = hostMediaFromEncoded(part.media);
+      if (typeof asset === "string")
+        throw new NativeReplayUnavailable(asset);
+      part.media = asset;
+    }
+  return result;
+}
+
+// src/v2/fold/restore.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/v2/hooks/storage-notice.ts
+var STORAGE_NOTICE_PREFIX = "[Magic Context storage notice] ";
+function formatStorageRefusalNotice(reason) {
+  return `${STORAGE_NOTICE_PREFIX}This turn was not sent to the model. ${formatFailClosedBlockingSummary(reason)}`;
+}
+function formatStorageRecoveryNotice(hiddenWorkRecovered) {
+  return hiddenWorkRecovered ? `${STORAGE_NOTICE_PREFIX}Magic Context storage is available again and turns are sent to the model. The historian and dreamer are running again. Restart OpenCode to enable Magic Context's tools.` : `${STORAGE_NOTICE_PREFIX}Magic Context storage is available again and turns are sent to the model. Restart OpenCode to enable Magic Context's tools, historian and dreamer.`;
+}
+function isStorageNoticeText(text) {
+  return typeof text === "string" && text.startsWith(STORAGE_NOTICE_PREFIX);
+}
+function hasStorageNoticeShape(message) {
+  if (message.role !== "user" || typeof message.id !== "string")
+    return false;
+  if (message.content.length !== 1)
+    return false;
+  const part = message.content[0];
+  return part?.type === "text" && isStorageNoticeText(part.text);
+}
+async function dropStorageNotices(messages, isAdmittedSynthetic) {
+  const drop = new Set;
+  for (const message of messages) {
+    if (!hasStorageNoticeShape(message))
+      continue;
+    if (await isAdmittedSynthetic(message.id))
+      drop.add(message);
+  }
+  if (drop.size === 0)
+    return 0;
+  const kept = messages.filter((message) => !drop.has(message));
+  messages.splice(0, messages.length, ...kept);
+  return drop.size;
+}
+
+// src/v2/fold/restore.ts
+function unavailableAttachmentNote(name, mediaType) {
+  return `[Attachment ${name ? `"${name}" ` : ""}(${mediaType}) is not available in this restored history]`;
+}
+var imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+function attachmentParts(files, rowID, media) {
+  const seen = new Map;
+  return files.flatMap((file) => {
+    if (imageMimes.has(file.mime) && file.source.type === "inline" && file.mention?.text) {
+      const key = JSON.stringify([
+        file.mime,
+        file.name ?? null,
+        file.description ?? null,
+        file.mention.text
+      ]);
+      const payloads = seen.get(key) ?? new Set;
+      if (payloads.has(file.data))
+        return [];
+      payloads.add(file.data);
+      seen.set(key, payloads);
+    }
+    const uri = file.source.type === "uri" ? file.source.uri : undefined;
+    const location = uri?.startsWith("file:") ? fileURLToPath2(uri) : undefined;
+    if (file.mime === "text/plain" || file.mime === "application/x-directory") {
+      const directory = file.mime === "application/x-directory";
+      return [
+        {
+          type: "text",
+          text: `
+
+${[
+            directory ? `Attached directory: ${location ?? file.name ?? uri ?? "directory"}` : `Attached file: ${file.name ?? uri ?? "inline attachment"}`,
+            file.description === undefined ? undefined : `Description: ${file.description}`,
+            directory && !file.data.length ? undefined : "",
+            directory && !file.data.length ? undefined : Buffer.from(file.data, "base64").toString("utf8")
           ].filter((line) => line !== undefined).join(`
 `)}`,
           metadata: {
@@ -18984,33 +19810,422 @@ ${data.output?.output ?? ""}`
         input = JSON.parse(input);
       } catch {}
     }
-    content.push({
-      type: "tool-call",
-      id: part.id,
-      name: part.name,
-      input,
-      providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
-    });
-    if (!completed)
-      continue;
-    const toolContent = state.content ?? [];
-    const single = toolContent.length === 1 ? toolContent[0] : undefined;
-    const result = {
-      type: "tool-result",
-      id: part.id,
-      name: part.name,
-      providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : 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" } : {}
-    };
-    if (part.executed === true)
-      content.push(result);
-    else
-      results.push({ role: "tool", content: [result] });
+    content.push({
+      type: "tool-call",
+      id: part.id,
+      name: part.name,
+      input,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
+    });
+    if (!completed)
+      continue;
+    const toolContent = state.content ?? [];
+    const single = toolContent.length === 1 ? toolContent[0] : undefined;
+    const result = {
+      type: "tool-result",
+      id: part.id,
+      name: part.name,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : 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" } : {}
+    };
+    if (part.executed === true)
+      content.push(result);
+    else
+      results.push({ role: "tool", content: [result] });
+  }
+  return [...content.length ? [make("assistant", content)] : [], ...results];
+}
+
+// src/v2/fold/native-replay.ts
+var coordinates = new WeakMap;
+function nativeRowID(message) {
+  return coordinates.get(message) ?? message.id;
+}
+function copyNativeInput(messages) {
+  const copies = reviveNative(encodeNative(messages));
+  copies.forEach((copy, i) => {
+    const original = messages[i];
+    const id = original && nativeRowID(original);
+    if (id !== undefined)
+      coordinates.set(copy, id);
+  });
+  return copies;
+}
+function isLocalCheckpoint(row) {
+  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined;
+}
+var conversational = (row) => RAW_MESSAGE_TYPES.includes(row.type) || row.type === "location-switched";
+
+class NativeFoldReplay {
+  storage;
+  openReader;
+  changed = new Set;
+  dirty = new Set;
+  unavailable = new Set;
+  metadata = new Map;
+  metadataThrough = new Map;
+  loaded = new Map;
+  sources = new Map;
+  constructor(storage, openReader) {
+    this.storage = storage;
+    this.openReader = openReader;
+    storage.onEvict((sessionID) => this.clear(sessionID));
+  }
+  account(sessionID) {
+    const source = this.sources.get(sessionID);
+    let bytes = 256 + (source?.length ?? 0) * 2;
+    for (const row of this.metadata.get(sessionID) ?? [])
+      bytes += 128 + (row.id.length + row.type.length) * 2;
+    this.storage.accountReplay(sessionID, bytes);
+  }
+  async observeSource(sessionID, reader) {
+    const source = reader.hostIdentity();
+    const prior = this.sources.get(sessionID);
+    if (prior && prior !== source)
+      await this.forget(sessionID);
+    this.sources.set(sessionID, source);
+    this.account(sessionID);
+  }
+  onEvent(event) {
+    const sessionID = event.data?.sessionID;
+    if (sessionID && (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated"))
+      this.invalidate(sessionID);
+  }
+  invalidate(sessionID, suppressNomination = false) {
+    if (suppressNomination)
+      this.unavailable.add(sessionID);
+    this.dirty.add(sessionID);
+    this.changed.add(sessionID);
+    this.metadata.delete(sessionID);
+    this.metadataThrough.delete(sessionID);
+    this.account(sessionID);
+  }
+  tail(sessionID) {
+    const record = this.storage.tail(sessionID);
+    return record ? JSON.parse(record.data) : undefined;
+  }
+  async baseline(sessionID) {
+    return this.tail(sessionID)?.baseline;
+  }
+  rendered(row, model) {
+    return restoreRow(row, model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: () => {}
+    } : undefined);
+  }
+  record(row, messages) {
+    const data = JSON.stringify(encodeNative(messages));
+    return { id: row.id, type: row.type, seq: row.seq, data, digest: foldDigest(data) };
+  }
+  records(sessionID, native, reader) {
+    let metadata = this.metadata.get(sessionID);
+    const through = reader.latestSequence(sessionID);
+    const known = new Set(metadata?.map((row) => row.id));
+    if (!metadata || (this.metadataThrough.get(sessionID) ?? -1) < through || native.some((message) => message.id && !known.has(message.id))) {
+      metadata = reader.rowStampsThrough(sessionID, through).filter(conversational);
+      this.metadata.set(sessionID, metadata);
+      this.metadataThrough.set(sessionID, through);
+    }
+    const byID = new Map(metadata.map((row) => [row.id, row]));
+    const grouped = new Map;
+    const anchorIndex = native.findIndex((message) => {
+      const id = nativeRowID(message);
+      return id !== undefined && byID.has(id);
+    });
+    const leading = native.slice(0, anchorIndex < 0 ? native.length : anchorIndex).filter((message) => !nativeRowID(message) && message.role === "system");
+    const anchorMessage = native[anchorIndex];
+    const anchorID = anchorMessage && nativeRowID(anchorMessage);
+    const anchor = anchorID ? byID.get(anchorID) : undefined;
+    const leadingRows = anchor ? metadata.filter((row) => row.type === "system" && row.seq < anchor.seq).slice(-leading.length) : [];
+    const leadingIDs = new Map(leading.map((message, i) => [message, leadingRows[i]?.id]));
+    let cursor = -1;
+    let owner;
+    for (const message of native) {
+      let id = nativeRowID(message);
+      if (!id && message.role === "system") {
+        if (leadingIDs.has(message)) {
+          id = leadingIDs.get(message);
+          if (!id)
+            continue;
+        } else
+          id = metadata.find((row) => row.type === "system" && row.seq > cursor)?.id;
+      }
+      if (!id && message.role === "tool")
+        id = owner;
+      const row = id ? byID.get(id) : undefined;
+      if (!row)
+        throw new NativeReplayUnavailable("Native carrier has no source row coordinate");
+      cursor = row.seq;
+      coordinates.set(message, row.id);
+      if (message.role !== "tool")
+        owner = row.id;
+      const messages = grouped.get(row) ?? [];
+      messages.push(message);
+      grouped.set(row, messages);
+    }
+    return [...grouped].map(([row, messages]) => this.record(row, messages));
+  }
+  async capture(draft, native) {
+    const release = this.storage.hold(draft.sessionID);
+    try {
+      rememberHostMedia(native);
+      const reader = this.openReader(draft.sessionID);
+      try {
+        const rows = this.records(draft.sessionID, native, reader);
+        const baseline = draft.messages.find((message) => message.id === HEAD_IDS[0])?.content.find((part) => part.type === "text")?.text;
+        const through = Math.max(-1, ...rows.map((row) => row.seq));
+        const tail = {
+          model: `${draft.model.providerID}/${draft.model.id}`,
+          sourceSeq: through,
+          baseline: typeof baseline === "string" ? baseline : this.tail(draft.sessionID)?.baseline
+        };
+        await this.storage.saveTail(draft.sessionID, JSON.stringify(tail), rows);
+        this.storage.truncate(draft.sessionID, through);
+        this.loaded.set(draft.sessionID, through);
+        this.unavailable.delete(draft.sessionID);
+        this.changed.delete(draft.sessionID);
+      } finally {
+        reader.close();
+      }
+    } catch {
+      this.unavailable.add(draft.sessionID);
+      this.invalidate(draft.sessionID);
+    } finally {
+      this.account(draft.sessionID);
+      release();
+    }
+  }
+  async canReplay(sessionID, _reader) {
+    return !this.unavailable.has(sessionID) && typeof await this.baseline(sessionID) === "string";
+  }
+  async supply(args) {
+    const release = this.storage.hold(args.draft.sessionID);
+    try {
+      return await this.supplyHeld(args);
+    } finally {
+      this.account(args.draft.sessionID);
+      release();
+    }
+  }
+  async supplyHeld(args) {
+    const { draft, reader, summary } = args;
+    const tail = this.tail(draft.sessionID);
+    const id = reader.latestRunningCompaction(draft.sessionID)?.id;
+    if (!id || !tail || tail.model !== `${draft.model.providerID}/${draft.model.id}`)
+      return false;
+    const through = reader.latestSequence(draft.sessionID);
+    const after = this.dirty.has(draft.sessionID) ? -1 : tail.sourceSeq;
+    const fresh = reader.range(draft.sessionID, after, through).filter(conversational);
+    const records = fresh.map((row) => this.record(row, this.rendered(row, draft.model)));
+    if (this.dirty.has(draft.sessionID))
+      this.storage.replaceRows(draft.sessionID, through, records);
+    await this.storage.saveTail(draft.sessionID, JSON.stringify({
+      ...tail,
+      sourceSeq: Math.max(tail.sourceSeq, ...fresh.map((row) => row.seq))
+    }), records);
+    this.dirty.delete(draft.sessionID);
+    this.metadata.delete(draft.sessionID);
+    this.metadataThrough.delete(draft.sessionID);
+    this.loaded.set(draft.sessionID, through);
+    const snapshot = {
+      source: this.storage.sourceID,
+      sessionID: draft.sessionID,
+      admissionID: id,
+      summary
+    };
+    await this.storage.supply(draft.sessionID, id, JSON.stringify(snapshot));
+    return true;
+  }
+  async restore(sessionID, cut, model, options = {}) {
+    const release = this.storage.hold(sessionID);
+    try {
+      return await this.restoreHeld(sessionID, cut, model, options);
+    } finally {
+      this.account(sessionID);
+      release();
+    }
+  }
+  async restoreHeld(sessionID, cut, model, options) {
+    if (!isLocalCheckpoint(cut))
+      return;
+    const resolvedModel = {
+      providerID: model.slice(0, model.indexOf("/")),
+      id: model.slice(model.indexOf("/") + 1)
+    };
+    const tail = this.tail(sessionID);
+    if (tail && tail.model !== model)
+      this.invalidate(sessionID);
+    let after = options.after ?? -1;
+    if (options.bounded && options.after === undefined && !this.changed.has(sessionID)) {
+      const state = getOrCreateSessionMeta(this.storage.db, sessionID);
+      const max = this.storage.db.prepare("SELECT COALESCE(MAX(id),0) AS id FROM m0_mutation_log WHERE session_id=?").get(sessionID);
+      const boundary = this.storage.db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id=?").get(sessionID)?.id;
+      if (max.id <= (state.cachedM0MaxMutationId ?? 0) && boundary)
+        after = this.storage.sequenceForID(sessionID, boundary) ?? -1;
+    }
+    const through = cut.seq - 1;
+    let reader;
+    try {
+      let metadata = this.metadata.get(sessionID);
+      if (!metadata || (this.metadataThrough.get(sessionID) ?? -1) < through) {
+        reader = this.openReader(sessionID);
+        metadata = reader.rowStampsThrough(sessionID, through).filter(conversational);
+        this.metadata.set(sessionID, metadata);
+        this.metadataThrough.set(sessionID, through);
+      }
+      const required = metadata.filter((row) => row.seq > after && row.seq <= through);
+      if (this.dirty.has(sessionID) || !tail || (this.loaded.get(sessionID) ?? -1) < through && !this.storage.admission(sessionID, cut.id) || !this.storage.containsRows(sessionID, required.map((row) => row.id))) {
+        reader ??= this.openReader(sessionID);
+        const fresh = reader.range(sessionID, after, through).filter(conversational);
+        const records = fresh.map((row) => this.record(row, this.rendered(row, resolvedModel)));
+        const restored = new Set(records.map((row) => row.id));
+        if (required.some((row) => !restored.has(row.id)))
+          throw new NativeReplayUnavailable("Host restore omitted a required source row");
+        this.storage.replaceRows(sessionID, through, records, after);
+        await this.storage.saveTail(sessionID, JSON.stringify({
+          model,
+          sourceSeq: through,
+          baseline: tail?.baseline ?? cut.data.summary
+        }), []);
+        this.loaded.set(sessionID, through);
+        this.dirty.delete(sessionID);
+      }
+    } finally {
+      reader?.close();
+    }
+    const messages = [];
+    for (const row of this.storage.rows(sessionID, after, cut.seq - 1)) {
+      const revived = reviveNative(JSON.parse(row.data));
+      for (const message of revived)
+        coordinates.set(message, row.id);
+      messages.push(...revived);
+    }
+    return messages;
+  }
+  async restoreRead(sessionID, cut, model) {
+    const reader = this.openReader(sessionID);
+    try {
+      return reader.range(sessionID, -1, cut.seq - 1).filter(conversational).flatMap((row) => {
+        const messages = this.rendered(row, model);
+        for (const message of messages)
+          coordinates.set(message, row.id);
+        return messages;
+      });
+    } finally {
+      reader.close();
+    }
+  }
+  sourceChanged(sessionID) {
+    return this.changed.has(sessionID);
+  }
+  clear(sessionID) {
+    this.sources.delete(sessionID);
+    this.metadata.delete(sessionID);
+    this.metadataThrough.delete(sessionID);
+    this.loaded.delete(sessionID);
+    this.unavailable.delete(sessionID);
+    this.dirty.delete(sessionID);
+    this.changed.delete(sessionID);
+  }
+  async forget(sessionID) {
+    await this.storage.forget(sessionID);
+  }
+}
+
+// src/v2/fold/policy.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+class HostFoldPolicy {
+  deps;
+  active = new Set;
+  owner = randomUUID3();
+  constructor(deps) {
+    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;
+  }
+  async idle(sessionID) {
+    const { storage, session, threshold } = this.deps;
+    if (!Number.isSafeInteger(threshold) || threshold <= 0 || typeof session.compact !== "function" || this.active.has(sessionID))
+      return;
+    this.active.add(sessionID);
+    const now = this.deps.now ?? Date.now;
+    let attempt;
+    let claimed = false;
+    try {
+      const reader = this.deps.openReader();
+      try {
+        const cut = reader.latestCompaction(sessionID);
+        const previous = storage.latestAttempt(sessionID);
+        const old = previous ? JSON.parse(previous.data) : undefined;
+        if (cut && previous?.status === "pending" && old && this.owned(sessionID, cut, old.id)) {
+          if (await storage.claim(sessionID, old.id, previous.data, this.owner, now()) && await storage.finish(sessionID, old.id, this.owner, "completed", now()))
+            this.deps.log(sessionID, `v2 host fold: rows_before=${old.before} rows_after=${reader.storedRowsAfter(sessionID, cut.seq)} duration_ms=${now() - old.started} reason=row_threshold id=${cut.id} status=completed`);
+          return;
+        }
+        const after = cut?.seq ?? -1;
+        const before = reader.storedRowsAfter(sessionID, after);
+        if (before < threshold || !await this.deps.canReplay(sessionID, reader))
+          return;
+        const retry = old?.after === after ? old.attempt + (previous?.status === "failed" || previous?.status === "coalesced" ? 1 : 0) : 0;
+        const id = old?.after === after && previous?.status === "pending" ? old.id : `msg_mc_fold_${foldDigest(`${storage.sourceID}/${sessionID}/${after}/${retry}`).slice(0, 24)}`;
+        attempt = {
+          after,
+          before,
+          watermark: reader.latestSequence(sessionID),
+          attempt: retry,
+          id,
+          started: now()
+        };
+        claimed = await storage.claim(sessionID, id, JSON.stringify(attempt), this.owner, now());
+        if (!claimed)
+          return;
+      } finally {
+        reader.close();
+      }
+      const admitted = await session.compact({
+        sessionID,
+        id: attempt.id,
+        delivery: "queue"
+      });
+      await session.wait({ sessionID });
+      const settled = this.deps.openReader();
+      try {
+        const cut = settled.latestCompaction(sessionID);
+        if (admitted?.id !== attempt.id || !cut || cut.seq <= attempt.after || !this.owned(sessionID, cut, attempt.id)) {
+          if (await storage.finish(sessionID, attempt.id, this.owner, "coalesced", now()))
+            this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=unknown duration_ms=${now() - attempt.started} reason=row_threshold id=${attempt.id} actual_id=${cut?.id ?? admitted?.id ?? "unknown"} status=coalesced`);
+          return;
+        }
+        const after = settled.storedRowsAfter(sessionID, cut.seq);
+        if (await storage.finish(sessionID, attempt.id, this.owner, "completed", now()))
+          this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=${after} duration_ms=${now() - attempt.started} reason=row_threshold id=${cut.id} status=completed`);
+      } finally {
+        settled.close();
+      }
+    } catch (error) {
+      if (claimed && attempt) {
+        let finished = false;
+        try {
+          finished = await storage.finish(sessionID, attempt.id, this.owner, "failed", now());
+        } catch {
+          finished = true;
+        }
+        if (finished)
+          this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=unknown duration_ms=${now() - attempt.started} reason=row_threshold id=${attempt.id} status=failed error=${JSON.stringify(String(error))}`);
+      } else
+        this.deps.log(sessionID, `v2 host fold: rows_before=unknown rows_after=unknown duration_ms=0 reason=row_threshold status=failed error=${JSON.stringify(String(error))} cache_error=${JSON.stringify(String(error))}`);
+    } finally {
+      this.active.delete(sessionID);
+    }
   }
-  return [...content.length ? [make("assistant", content)] : [], ...results];
 }
 
 // src/v2/fork-inheritance.ts
@@ -19133,12 +20348,13 @@ function seedV2ForkFromParent(args) {
 function keptUnderRetention(keepSubagents, child) {
   return keepSubagents && (child.ever_settled === true || child.role === "historian");
 }
+var HIDDEN_CHILD_ROLE_TITLES = {
+  "maintainer-a": "Magic Context maintainer A",
+  "maintainer-b": "Magic Context maintainer B",
+  historian: "Magic Context historian"
+};
 function roleTitle(role) {
-  if (role === "maintainer-a")
-    return "Magic Context maintainer A";
-  if (role === "maintainer-b")
-    return "Magic Context maintainer B";
-  return "Magic Context historian";
+  return HIDDEN_CHILD_ROLE_TITLES[role];
 }
 function roleAgent(role) {
   if (role === "maintainer-a")
@@ -19700,694 +20916,315 @@ 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 });
-      try {
-        await Promise.race([
-          host.prompt({ sessionID: run.child.id, text: marker }),
-          aborted
-        ]);
-        await Promise.race([host.wait({ sessionID: run.child.id }), aborted]);
-        const row = await Promise.race([
-          awaitAssistantRow(options.openReader, async () => {
-            try {
-              const eventError = await host.terminalError?.({
-                sessionID: run.child.id
-              });
-              if (eventError !== undefined)
-                return eventError;
-              return (await host.get({ sessionID: run.child.id })).error;
-            } catch {
-              return;
-            }
-          }, () => attempt.refusal ?? attempt.stepLimit, run.child.id, baseline, deadline, request.signal),
-          aborted
-        ]);
-        if (!attempt.shaped) {
-          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Host did not dispatch the hidden child context hook", true);
-        }
-        const text = assistantText(row);
-        const system = typeof request.body.system === "string" ? request.body.system : run.identity.system;
-        const tokens = row.data.tokens;
-        const tokenNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
-        const reportedInput = tokenNumber(tokens?.input);
-        const reportedOutput = tokenNumber(tokens?.output);
-        if (request.signal?.aborted || run.retired || Date.now() >= deadline) {
-          await interruptAndRetire(run, "prompt-aborted-or-timeout");
-          throw new Error(request.signal?.aborted ? "Hidden completion prompt aborted" : "Hidden completion prompt timed out");
-        }
-        run.completion = {
-          text,
-          tokenLog: runTokenLog(tokens, run.identity.maxOutputTokens, row.data.finish),
-          reasoning: text ? null : assistantReasoning(row),
-          usage: reportedInput !== undefined || reportedOutput !== undefined ? {
-            input: reportedInput ?? 0,
-            output: reportedOutput ?? 0,
-            cacheRead: tokenNumber(tokens?.cache?.read) ?? 0,
-            cacheWrite: tokenNumber(tokens?.cache?.write) ?? 0
-          } : meter(system, promptText(request), text ?? ""),
-          lengthCapped: ["length", "max_tokens"].includes(row.data.finish ?? ""),
-          providerId: row.data.model?.providerID ?? requested.providerID,
-          modelId: row.data.model?.id ?? requested.modelID,
-          ...attempt.steps === undefined ? {} : { steps: attempt.steps }
-        };
-        if (!run.child.ever_settled)
-          run.child = lifecycle.markEverSettled(run.child);
-      } catch (caught) {
-        const error = attempt.stepLimit ?? attempt.refusal ?? caught;
-        run.failed = true;
-        if (!(error instanceof HiddenProviderError)) {
-          run.unsettledFailure = true;
-        }
-        if (request.signal?.aborted && !run.retired) {
-          await interruptAndRetire(run, "prompt-aborted");
-        } else if (error instanceof Error && error.message.includes("timed out") && !run.retired) {
-          await interruptAndRetire(run, "prompt-timeout");
-        } else if ((error instanceof HiddenAgentStepLimit || error instanceof HiddenProviderError && error.settled) && !run.retired) {
-          await interruptAndRetire(run, error instanceof HiddenAgentStepLimit ? "hidden-run-step-limit" : "hidden-run-provider-error");
-        }
-        throw error;
-      } finally {
-        clearTimeout(deadlineTimer);
-        request.signal?.removeEventListener("abort", onAbort);
-        options.hook.releaseAttempt(marker);
-      }
-    },
-    async collect(handle) {
-      const completion = runs.get(handle)?.completion;
-      if (!completion)
-        throw new Error("Hidden completion has no settled output");
-      return completion;
-    },
-    async close(handle, settlement) {
-      if (!handle)
-        return;
-      const run = runs.get(handle);
-      if (!run)
-        return;
-      try {
-        const reusable = !run.retired && run.failed && !run.unsettledFailure;
-        if (!run.completion && (run.failed || !settlement.promptSettled) && !reusable) {
-          retire(run, "hidden-run-failed");
-        }
-      } finally {
-        runs.delete(handle);
-        run.releaseRole();
-      }
-      await lifecycle.finish(run.child, run.retired);
-    }
-  };
-}
-
-// src/v2/hooks/channel2.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-var pendingCandidates = new WeakMap;
-function syntheticCandidates(context, sessionID, stored) {
-  const pending = pendingCandidates.get(context.storage);
-  for (const [key, id] of pending ?? []) {
-    if (!key.startsWith(`${sessionID}/`))
-      continue;
-    if (stored.has(id))
-      pending?.delete(key);
-    else
-      stored.add(id);
-  }
-  return stored;
-}
-function clearSyntheticCandidates(context) {
-  pendingCandidates.delete(context.storage);
-}
-async function deliverSynthetic(context, sessionID, text) {
-  const id = `msg_${randomBytes2(12).toString("hex")}`;
-  await context.storage.set(`synthetic/${sessionID}/${id}`, { id });
-  let candidates = pendingCandidates.get(context.storage);
-  if (!candidates) {
-    candidates = new Map;
-    pendingCandidates.set(context.storage, candidates);
-  }
-  candidates.set(`${sessionID}/${id}`, id);
-  await context.session.synthetic({ sessionID, id, text, delivery: "steer" });
-  return id;
-}
-async function isAdmittedSynthetic(context, sessionID, id) {
-  const record = await context.storage.get(`synthetic/${sessionID}/${id}`);
-  return record !== null && typeof record === "object" && "id" in record && record.id === id;
-}
-async function deliverPendingChannel2(context, db, sessionID, baseline) {
-  if (getChannel2NudgeState(db, sessionID) !== "pending")
-    return;
-  const evaluation = evaluateChannel2(baseline);
-  if (!evaluation.evaluable || !evaluation.shouldTrigger)
-    return;
-  const token = randomBytes2(16).toString("hex");
-  if (!claimChannel2NudgeState(db, sessionID, token))
-    return;
-  try {
-    await deliverSynthetic(context, sessionID, buildChannel2Reminder(evaluation.reclaimableTokens, reclaimableToolOutputCount(baseline?.baselineParts ?? [])));
-  } catch (error) {
-    casChannel2NudgeClaim(db, sessionID, "pending", token);
-    throw error;
-  }
-  casChannel2NudgeClaim(db, sessionID, "delivered", token);
-}
-
-// src/v2/hooks/commands.ts
-async function registerV2Commands(args) {
-  const domain = args.command;
-  if (!domain || typeof domain.transform !== "function") {
-    log("[magic-context] v2 host exposes no command domain; /mmc-* commands are TUI-only");
-    return false;
-  }
-  const descriptions = getMagicContextBuiltinCommands(args.compactionEnabled);
-  const commands = buildV2Commands(args.rpc, args.directory);
-  try {
-    await domain.transform((editor) => {
-      for (const command of commands) {
-        editor.add({
-          name: command.name,
-          description: descriptions[command.name].description,
-          execute: command.execute
-        });
-      }
-    });
-  } catch (error) {
-    log("[magic-context] v2 command registration failed", error);
-    return false;
-  }
-  log(`[magic-context] registered server-side commands: ${commands.map((command) => command.name).join(" ")}`);
-  return true;
-}
-function commandArgument(input, name) {
-  const raw = typeof input.prompt?.text === "string" ? input.prompt.text.trim() : "";
-  const prefix = `/${name}`;
-  if (raw === prefix)
-    return "";
-  if (raw.startsWith(`${prefix} `))
-    return raw.slice(prefix.length).trim();
-  return raw;
-}
-function reportResult(sessionID, title, message) {
-  pushNotification2("action", { action: "show-result-dialog", title, message }, sessionID);
-}
-function reportUsage(sessionID, message) {
-  pushNotification2("toast", { message, variant: "warning" }, sessionID);
-}
-function reportRpcReply(sessionID, title, reply, pending) {
-  if (reply.ok !== true) {
-    const error = typeof reply.error === "string" ? reply.error : `${title} request failed`;
-    pushNotification2("toast", { message: error, variant: "error" }, sessionID);
-    return;
-  }
-  if (reply.started === true) {
-    pushNotification2("toast", { message: pending, variant: "info" }, sessionID);
-    return;
-  }
-  reportResult(sessionID, title, typeof reply.message === "string" ? reply.message : "");
-}
-function buildV2Commands(rpc, directory) {
-  return [
-    {
-      name: "mmc-status",
-      execute: async (input) => {
-        const detail = await rpc.dispatch("status-detail", {
-          sessionId: input.sessionID,
-          directory
-        });
-        if (typeof detail.error === "string") {
-          throw new Error(`Magic Context status is unavailable: ${detail.error}`);
-        }
-        pushNotification2("action", { action: "show-status-dialog" }, input.sessionID);
-      }
-    },
-    {
-      name: "mmc-recomp",
-      execute: async (input) => {
-        if (isTuiConnected2(input.sessionID)) {
-          pushNotification2("action", { action: "show-recomp-dialog" }, input.sessionID);
-          return;
+      try {
+        await Promise.race([
+          host.prompt({ sessionID: run.child.id, text: marker }),
+          aborted
+        ]);
+        await Promise.race([host.wait({ sessionID: run.child.id }), aborted]);
+        const row = await Promise.race([
+          awaitAssistantRow(options.openReader, async () => {
+            try {
+              const eventError = await host.terminalError?.({
+                sessionID: run.child.id
+              });
+              if (eventError !== undefined)
+                return eventError;
+              return (await host.get({ sessionID: run.child.id })).error;
+            } catch {
+              return;
+            }
+          }, () => attempt.refusal ?? attempt.stepLimit, run.child.id, baseline, deadline, request.signal),
+          aborted
+        ]);
+        if (!attempt.shaped) {
+          const task = run.identity.title.replace(/^magic-context-dream-/, "");
+          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", `Host did not dispatch the hidden child context hook (task=${task}, agent=${run.identity.agent}, child=${run.child.id}, directory=${run.identity.directory}, stage=context/HiddenChildHook.apply). Check that the child's location loads the owning Magic Context instance; changing models cannot repair missing context shaping.`, true);
         }
-        const reply = await rpc.dispatch("recomp", { sessionId: input.sessionID });
-        if (reply.ok !== true) {
-          throw new Error("Magic Context could not start the history rebuild.");
+        const text = assistantText(row);
+        const system = typeof request.body.system === "string" ? request.body.system : run.identity.system;
+        const tokens = row.data.tokens;
+        const tokenNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+        const reportedInput = tokenNumber(tokens?.input);
+        const reportedOutput = tokenNumber(tokens?.output);
+        if (request.signal?.aborted || run.retired || Date.now() >= deadline) {
+          await interruptAndRetire(run, "prompt-aborted-or-timeout");
+          throw new Error(request.signal?.aborted ? "Hidden completion prompt aborted" : "Hidden completion prompt timed out");
         }
-      }
-    },
-    {
-      name: "mmc-flush",
-      execute: async (input) => {
-        const reply = await rpc.dispatch("flush", { sessionId: input.sessionID });
-        reportRpcReply(input.sessionID, "Flush", reply, "Flush started");
-      }
-    },
-    {
-      name: "mmc-wrapup",
-      execute: async (input) => {
-        const argument = commandArgument(input, "mmc-wrapup");
-        if (argument !== "" && !/^\d+$/.test(argument)) {
-          const usage = "Usage: /mmc-wrapup [messages_to_keep] where messages_to_keep is a positive integer";
-          reportUsage(input.sessionID, usage);
-          throw new Error(usage);
+        run.completion = {
+          text,
+          tokenLog: runTokenLog(tokens, run.identity.maxOutputTokens, row.data.finish),
+          reasoning: text ? null : assistantReasoning(row),
+          usage: reportedInput !== undefined || reportedOutput !== undefined ? {
+            input: reportedInput ?? 0,
+            output: reportedOutput ?? 0,
+            cacheRead: tokenNumber(tokens?.cache?.read) ?? 0,
+            cacheWrite: tokenNumber(tokens?.cache?.write) ?? 0
+          } : meter(system, promptText(request), text ?? ""),
+          lengthCapped: ["length", "max_tokens"].includes(row.data.finish ?? ""),
+          providerId: row.data.model?.providerID ?? requested.providerID,
+          modelId: row.data.model?.id ?? requested.modelID,
+          ...attempt.steps === undefined ? {} : { steps: attempt.steps }
+        };
+        if (!run.child.ever_settled)
+          run.child = lifecycle.markEverSettled(run.child);
+      } catch (caught) {
+        const error = attempt.stepLimit ?? attempt.refusal ?? caught;
+        run.failed = true;
+        if (!(error instanceof HiddenProviderError)) {
+          run.unsettledFailure = true;
         }
-        const messagesToKeep = argument === "" ? 20 : Number.parseInt(argument, 10);
-        if (messagesToKeep <= 0) {
-          const usage = "messages_to_keep must be a positive integer";
-          reportUsage(input.sessionID, usage);
-          throw new Error(usage);
+        if (request.signal?.aborted && !run.retired) {
+          await interruptAndRetire(run, "prompt-aborted");
+        } else if (error instanceof Error && error.message.includes("timed out") && !run.retired) {
+          await interruptAndRetire(run, "prompt-timeout");
+        } else if ((error instanceof HiddenAgentStepLimit || error instanceof HiddenProviderError && error.settled) && !run.retired) {
+          await interruptAndRetire(run, error instanceof HiddenAgentStepLimit ? "hidden-run-step-limit" : "hidden-run-provider-error");
         }
-        const reply = await rpc.dispatch("wrapup", {
-          sessionId: input.sessionID,
-          messagesToKeep
-        });
-        reportRpcReply(input.sessionID, "Wrapup", reply, "Wrapup started; the summary appears when it finishes");
+        throw error;
+      } finally {
+        clearTimeout(deadlineTimer);
+        request.signal?.removeEventListener("abort", onAbort);
+        options.hook.releaseAttempt(marker);
       }
     },
-    {
-      name: "mmc-memory-maintain",
-      execute: async (input) => {
-        const argument = commandArgument(input, "mmc-memory-maintain");
-        const subcommand = argument === "" ? "status" : argument.trim().toLowerCase();
-        if (subcommand !== "run" && subcommand !== "status" && subcommand !== "resume") {
-          const usage = "Usage: /mmc-memory-maintain [run|status|resume] — status is the default";
-          reportUsage(input.sessionID, usage);
-          throw new Error(usage);
+    async collect(handle) {
+      const completion = runs.get(handle)?.completion;
+      if (!completion)
+        throw new Error("Hidden completion has no settled output");
+      return completion;
+    },
+    async close(handle, settlement) {
+      if (!handle)
+        return;
+      const run = runs.get(handle);
+      if (!run)
+        return;
+      try {
+        const reusable = !run.retired && run.failed && !run.unsettledFailure;
+        if (!run.completion && (run.failed || !settlement.promptSettled) && !reusable) {
+          retire(run, "hidden-run-failed");
         }
-        const reply = await rpc.dispatch("maintenance", {
-          sessionId: input.sessionID,
-          subcommand
-        });
-        reportRpcReply(input.sessionID, "Memory maintenance", reply, "Maintenance run started; see /mmc-memory-maintain status for the outcome");
+      } finally {
+        runs.delete(handle);
+        run.releaseRole();
       }
+      await lifecycle.finish(run.child, run.retired);
     }
-  ];
+  };
 }
 
-// src/v2/hooks/deleted-session-tombstones.ts
-class DeletedSessionTombstones {
-  limit;
-  #ids = new Set;
-  constructor(limit = 1000) {
-    this.limit = limit;
-    if (!Number.isSafeInteger(limit) || limit < 1) {
-      throw new Error("Deleted-session tombstone limit must be a positive integer");
-    }
-  }
-  add(sessionID) {
-    this.#ids.delete(sessionID);
-    this.#ids.add(sessionID);
-    while (this.#ids.size > this.limit) {
-      const oldest = this.#ids.values().next().value;
-      if (oldest === undefined)
-        break;
-      this.#ids.delete(oldest);
-    }
-  }
-  has(sessionID) {
-    return this.#ids.has(sessionID);
-  }
-  clear() {
-    this.#ids.clear();
-  }
-  get size() {
-    return this.#ids.size;
+// src/v2/hooks/channel2.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var pendingCandidates = new WeakMap;
+function syntheticCandidates(context, sessionID, stored) {
+  const pending = pendingCandidates.get(context.storage);
+  for (const [key, id] of pending ?? []) {
+    if (!key.startsWith(`${sessionID}/`))
+      continue;
+    if (stored.has(id))
+      pending?.delete(key);
+    else
+      stored.add(id);
   }
+  return stored;
 }
-
-// src/v2/tool-result.ts
-function isToolError(part) {
-  const result = part.result;
-  return part.resultType === "error" || result?.type === "error" || result !== null && typeof result === "object" && "error" in result;
-}
-function toolErrorText(result) {
-  const value = result.value === undefined ? result : result.value;
-  return typeof value === "string" ? value : JSON.stringify(value);
-}
-function toolStateContent(state) {
-  if (typeof state.output === "string")
-    return state.output;
-  if (state.status === "error")
-    return toolErrorText({ error: state.error, content: state.content ?? [] });
-  if (typeof state.content === "string")
-    return state.content;
-  if (!Array.isArray(state.content))
-    return "";
-  return state.content.map((part) => {
-    if (typeof part === "string")
-      return part;
-    if (!part || typeof part !== "object")
-      return "";
-    const value = part;
-    if (typeof value.text === "string")
-      return value.text;
-    if (typeof value.value === "string")
-      return value.value;
-    return "";
-  }).filter(Boolean).join(`
-`);
-}
-
-// src/v2/hooks/payload.ts
-var HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
-var HOST_CONTENT_TYPES = new Set([
-  "text",
-  "media",
-  "tool-call",
-  "tool-result",
-  "reasoning",
-  "compaction",
-  "effort"
-]);
-function rejectContentPart(message, part, reason) {
-  const type = typeof part.type === "string" ? part.type : "<missing>";
-  const text = `v2 context omitted a content part the host would reject: type=${type} message=${String(message.info.id ?? "<head>")} reason=${reason}`;
-  if (typeof message.info.sessionID === "string")
-    sessionLog(message.info.sessionID, text);
-  else
-    log(text);
-}
-function isHostInstance(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype !== Object.prototype && prototype !== null;
-}
-function containsHostInstance(value) {
-  if (isHostInstance(value))
-    return true;
-  if (Array.isArray(value))
-    return value.some(containsHostInstance);
-  if (value && typeof value === "object")
-    return Object.values(value).some(containsHostInstance);
-  return false;
+function clearSyntheticCandidates(context) {
+  pendingCandidates.delete(context.storage);
 }
-function clonePreservingInstances(value) {
-  if (isHostInstance(value))
-    return value;
-  if (Array.isArray(value))
-    return value.map(clonePreservingInstances);
-  if (value && typeof value === "object") {
-    const copy = {};
-    for (const [key, entry] of Object.entries(value))
-      copy[key] = clonePreservingInstances(entry);
-    return copy;
+async function deliverSynthetic(context, sessionID, text) {
+  const id = `msg_${randomBytes2(12).toString("hex")}`;
+  await context.storage.set(`synthetic/${sessionID}/${id}`, { id });
+  let candidates = pendingCandidates.get(context.storage);
+  if (!candidates) {
+    candidates = new Map;
+    pendingCandidates.set(context.storage, candidates);
   }
-  return value;
+  candidates.set(`${sessionID}/${id}`, id);
+  await context.session.synthetic({ sessionID, id, text, delivery: "steer" });
+  return id;
 }
-function contentKey(value) {
-  const plain = (entry) => {
-    if (ArrayBuffer.isView(entry)) {
-      return {
-        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
-      };
-    }
-    if (Array.isArray(entry))
-      return entry.map(plain);
-    if (entry && typeof entry === "object") {
-      return Object.fromEntries(Object.entries(entry).map(([key, nested]) => [key, plain(nested)]));
-    }
-    return entry;
-  };
-  return JSON.stringify(plain(value));
+async function isAdmittedSynthetic(context, sessionID, id) {
+  const record = await context.storage.get(`synthetic/${sessionID}/${id}`);
+  return record !== null && typeof record === "object" && "id" in record && record.id === id;
 }
-function fileContentValue(result) {
-  const value = result?.value;
-  if (result?.type !== "content" || !Array.isArray(value))
+async function deliverPendingChannel2(context, db, sessionID, baseline) {
+  if (getChannel2NudgeState(db, sessionID) !== "pending")
     return;
-  return value.some((item) => item?.type === "file") ? value : undefined;
+  const evaluation = evaluateChannel2(baseline);
+  if (!evaluation.evaluable || !evaluation.shouldTrigger)
+    return;
+  const token = randomBytes2(16).toString("hex");
+  if (!claimChannel2NudgeState(db, sessionID, token))
+    return;
+  try {
+    await deliverSynthetic(context, sessionID, buildChannel2Reminder(evaluation.reclaimableTokens, reclaimableToolOutputCount(baseline?.baselineParts ?? [])));
+  } catch (error) {
+    casChannel2NudgeClaim(db, sessionID, "pending", token);
+    throw error;
+  }
+  casChannel2NudgeClaim(db, sessionID, "delivered", token);
 }
-function contentValueText(value) {
-  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
-`);
+
+// src/v2/hooks/commands.ts
+async function registerV2Commands(args) {
+  const domain = args.command;
+  if (!domain || typeof domain.transform !== "function") {
+    log("[magic-context] v2 host exposes no command domain; /mmc-* commands are TUI-only");
+    return false;
+  }
+  const descriptions = getMagicContextBuiltinCommands(args.compactionEnabled);
+  const commands = buildV2Commands(args.rpc, args.directory);
+  try {
+    await domain.transform((editor) => {
+      for (const command of commands) {
+        editor.add({
+          name: command.name,
+          description: descriptions[command.name].description,
+          execute: command.execute
+        });
+      }
+    });
+  } catch (error) {
+    log("[magic-context] v2 command registration failed", error);
+    return false;
+  }
+  log(`[magic-context] registered server-side commands: ${commands.map((command) => command.name).join(" ")}`);
+  return true;
 }
-function contentValueAttachments(value) {
-  return value.filter((item) => item?.type === "file").map((item) => ({
-    type: "file",
-    mime: item.mime,
-    url: item.uri,
-    ...typeof item.name === "string" ? { filename: item.name } : {}
-  }));
+function commandArgument(input, name) {
+  const raw = typeof input.prompt?.text === "string" ? input.prompt.text.trim() : "";
+  const prefix = `/${name}`;
+  if (raw === prefix)
+    return "";
+  if (raw.startsWith(`${prefix} `))
+    return raw.slice(prefix.length).trim();
+  return raw;
 }
-function rebuildFileContent(value, output) {
-  if (isDroppedToolOutput(output))
-    return { type: "text", value: output };
-  const rebuilt = [];
-  let placed = false;
-  for (const item of value) {
-    if (item?.type !== "text") {
-      rebuilt.push(item);
-      continue;
-    }
-    if (placed)
-      continue;
-    placed = true;
-    rebuilt.push({ ...item, text: output });
-  }
-  if (!placed && output)
-    rebuilt.unshift({ type: "text", text: output });
-  return { type: "content", value: rebuilt };
+function reportResult(sessionID, title, message) {
+  pushNotification2("action", { action: "show-result-dialog", title, message }, sessionID);
 }
-function adaptPayload(draft, admittedIDs = new Set) {
-  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;
-  const hostParts = new Map;
-  const hostPartTypes = new Set;
-  for (const message of source) {
-    for (const part of message.content) {
-      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
-        const key = contentKey(part);
-        if (!hostParts.has(key))
-          hostParts.set(key, part);
-        hostPartTypes.add(part.type);
-      }
-      if (part.type === "tool-result" && typeof part.id === "string") {
-        const queue = results.get(part.id) ?? [];
-        queue.push({ part, message });
-        results.set(part.id, queue);
-      }
-    }
+function reportUsage(sessionID, message) {
+  pushNotification2("toast", { message, variant: "warning" }, sessionID);
+}
+function reportRpcReply(sessionID, title, reply, pending) {
+  if (reply.ok !== true) {
+    const error = typeof reply.error === "string" ? reply.error : `${title} request failed`;
+    pushNotification2("toast", { message: error, variant: "error" }, sessionID);
+    return;
   }
-  const paired = new Set;
-  const bridges = new Map;
-  const originals = new Map;
-  const bridgesByMessageID = new Map;
-  const bridgesByCarrier = new Map;
-  const originalsByID = new Map;
-  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
-  const nativeTool = (call, result) => {
-    const hostResult = result?.part.result;
-    const failed = result !== undefined && isToolError(result.part);
-    const value = hostResult?.value;
-    const files = fileContentValue(hostResult);
-    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
-    const part = {
-      type: "tool",
-      callID: call?.id ?? result?.part.id,
-      tool: call?.name ?? result?.part.name,
-      state: {
-        input: structuredClone(call?.input ?? {}),
-        status: failed ? "error" : result ? "completed" : "running",
-        ...result ? { output } : {},
-        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
-        ...files ? { attachments: contentValueAttachments(files) } : {}
+  if (reply.started === true) {
+    pushNotification2("toast", { message: pending, variant: "info" }, sessionID);
+    return;
+  }
+  reportResult(sessionID, title, typeof reply.message === "string" ? reply.message : "");
+}
+function buildV2Commands(rpc, directory) {
+  return [
+    {
+      name: "mmc-status",
+      execute: async (input) => {
+        const detail = await rpc.dispatch("status-detail", {
+          sessionId: input.sessionID,
+          directory
+        });
+        if (typeof detail.error === "string") {
+          throw new Error(`Magic Context status is unavailable: ${detail.error}`);
+        }
+        pushNotification2("action", { action: "show-status-dialog" }, input.sessionID);
       }
-    };
-    bridges.set(part, {
-      call,
-      result: result?.part,
-      resultMessage: result?.message,
-      output,
-      files
-    });
-    if (result)
-      paired.add(result.part);
-    return part;
-  };
-  const convertedTool = (source) => {
-    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
-    const output = toolStateContent(sourceState);
-    const { content: _content, ...projectedState } = structuredClone(sourceState);
-    const part = {
-      type: "tool",
-      callID: source.callID ?? source.id,
-      tool: source.tool ?? source.name,
-      state: { ...projectedState, output }
-    };
-    bridges.set(part, { native: source, output });
-    return part;
-  };
-  const callParts = new Map;
-  for (const message of source) {
-    for (const part of message.content) {
-      if (part.type === "tool-call") {
-        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
-      } else if (part.type === "tool") {
-        callParts.set(part, convertedTool(part));
+    },
+    {
+      name: "mmc-recomp",
+      execute: async (input) => {
+        if (isTuiConnected2(input.sessionID)) {
+          pushNotification2("action", { action: "show-recomp-dialog" }, input.sessionID);
+          return;
+        }
+        const reply = await rpc.dispatch("recomp", { sessionId: input.sessionID });
+        if (reply.ok !== true) {
+          throw new Error("Magic Context could not start the history rebuild.");
+        }
       }
-    }
-  }
-  const messages = [];
-  for (const message of source) {
-    const parts = [];
-    for (const content of message.content) {
-      if (paired.has(content))
-        continue;
-      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
-      if (message.id && admittedIDs.has(message.id))
-        part.synthetic = true;
-      parts.push(part);
-    }
-    if (!parts.length && message.content.length)
-      continue;
-    const byCallID = new Map;
-    for (const part of parts) {
-      const bridge = bridges.get(part);
-      if (bridge && typeof part.callID === "string")
-        byCallID.set(part.callID, bridge);
-    }
-    if (typeof message.id === "string") {
-      bridgesByMessageID.set(message.id, byCallID);
-      originalsByID.set(message.id, message);
-    }
-    const mapped = {
-      info: {
-        id: message.id,
-        sessionID: draft.sessionID,
-        role: message.role,
-        ...{
-          providerID: draft.model.providerID,
-          modelID: draft.model.id,
-          agent: draft.agent
+    },
+    {
+      name: "mmc-flush",
+      execute: async (input) => {
+        const reply = await rpc.dispatch("flush", { sessionId: input.sessionID });
+        reportRpcReply(input.sessionID, "Flush", reply, "Flush started");
+      }
+    },
+    {
+      name: "mmc-wrapup",
+      execute: async (input) => {
+        const argument = commandArgument(input, "mmc-wrapup");
+        if (argument !== "" && !/^\d+$/.test(argument)) {
+          const usage = "Usage: /mmc-wrapup [messages_to_keep] where messages_to_keep is a positive integer";
+          reportUsage(input.sessionID, usage);
+          throw new Error(usage);
         }
-      },
-      parts
-    };
-    originals.set(mapped, message);
-    if (typeof message.id !== "string")
-      bridgesByCarrier.set(mapped, byCallID);
-    messages.push(mapped);
-  }
-  return {
-    messages,
-    commit() {
-      let head = 0;
-      const rendered = [];
-      for (const message of messages) {
-        const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
-        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
-        const content = [];
-        const following = [];
-        for (const candidate of message.parts) {
-          const part = candidate;
-          const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
-          if (!bridge) {
-            if (part.type === "tool") {
-              const state = part.state;
-              if (typeof part.callID !== "string" || typeof part.tool !== "string" || !state || typeof state !== "object") {
-                rejectContentPart(message, part, "tool has no call ID, name, or state");
-                continue;
-              }
-              content.push({
-                type: "tool-call",
-                id: part.callID,
-                name: part.tool,
-                input: state.input
-              });
-              if (state.status === "completed" || state.status === "error") {
-                following.push({
-                  role: "tool",
-                  content: [
-                    {
-                      type: "tool-result",
-                      id: part.callID,
-                      name: part.tool,
-                      result: {
-                        type: state.status === "error" ? "error" : "text",
-                        value: toolStateContent(state)
-                      }
-                    }
-                  ]
-                });
-              }
-              continue;
-            }
-            if (part.type === "file") {
-              const mime = part.mime;
-              const url = part.url;
-              const prefix = `data:${mime};base64,`;
-              if (typeof mime !== "string" || !/^image\/(png|jpeg|gif|webp)$/.test(mime) || typeof url !== "string" || !url.startsWith(prefix)) {
-                rejectContentPart(message, part, "file is not an inline supported image");
-                continue;
-              }
-              const asset = hostMediaAsset(url.slice(prefix.length), mime);
-              if (typeof asset === "string") {
-                rejectContentPart(message, part, `host media unavailable: ${asset}`);
-                continue;
-              }
-              content.push({ type: "media", media: asset });
-              continue;
-            }
-            if (!HOST_CONTENT_TYPES.has(String(part.type))) {
-              rejectContentPart(message, part, "unknown host content type");
-              continue;
-            }
-            const { synthetic: _synthetic, ...clean } = part;
-            const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
-            content.push(original ?? clean);
-            continue;
-          }
-          const state = part.state;
-          if (bridge.native) {
-            const native = bridge.native;
-            const callID = String(native.id ?? native.callID ?? part.callID);
-            const name = String(native.name ?? native.tool ?? part.tool);
-            content.push({ type: "tool-call", id: callID, name, input: state.input });
-            if (state.status === "completed" || state.status === "error") {
-              following.push({
-                role: "tool",
-                content: [
-                  {
-                    type: "tool-result",
-                    id: callID,
-                    name,
-                    result: {
-                      type: state.status === "error" ? "error" : "text",
-                      value: state.output
-                    }
-                  }
-                ]
-              });
-            }
-            continue;
-          }
-          if (bridge.call)
-            content.push({ ...bridge.call, input: state.input });
-          if (bridge.result && bridge.resultMessage) {
-            const result = {
-              ...bridge.result,
-              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
-                type: state.status === "error" ? "error" : "text",
-                value: state.output
-              }
-            };
-            if (bridge.resultMessage === original)
-              content.push(result);
-            else
-              following.push({ ...bridge.resultMessage, content: [result] });
-          }
+        const messagesToKeep = argument === "" ? 20 : Number.parseInt(argument, 10);
+        if (messagesToKeep <= 0) {
+          const usage = "messages_to_keep must be a positive integer";
+          reportUsage(input.sessionID, usage);
+          throw new Error(usage);
         }
-        if (content.length || !original?.content.length) {
-          const value = {
-            ...original,
-            id,
-            role: message.info.role ?? "user",
-            content
-          };
-          const existing = id ? existingHeads.get(id) : undefined;
-          rendered.push(existing ? Object.assign(existing, { content }) : value);
+        const reply = await rpc.dispatch("wrapup", {
+          sessionId: input.sessionID,
+          messagesToKeep
+        });
+        reportRpcReply(input.sessionID, "Wrapup", reply, "Wrapup started; the summary appears when it finishes");
+      }
+    },
+    {
+      name: "mmc-memory-maintain",
+      execute: async (input) => {
+        const argument = commandArgument(input, "mmc-memory-maintain");
+        const subcommand = argument === "" ? "status" : argument.trim().toLowerCase();
+        if (subcommand !== "run" && subcommand !== "status" && subcommand !== "resume") {
+          const usage = "Usage: /mmc-memory-maintain [run|status|resume] — status is the default";
+          reportUsage(input.sessionID, usage);
+          throw new Error(usage);
         }
-        rendered.push(...following);
+        const reply = await rpc.dispatch("maintenance", {
+          sessionId: input.sessionID,
+          subcommand
+        });
+        reportRpcReply(input.sessionID, "Memory maintenance", reply, "Maintenance run started; see /mmc-memory-maintain status for the outcome");
       }
-      draft.messages.splice(0, draft.messages.length, ...rendered);
     }
-  };
+  ];
+}
+
+// src/v2/hooks/deleted-session-tombstones.ts
+class DeletedSessionTombstones {
+  limit;
+  #ids = new Set;
+  constructor(limit = 1000) {
+    this.limit = limit;
+    if (!Number.isSafeInteger(limit) || limit < 1) {
+      throw new Error("Deleted-session tombstone limit must be a positive integer");
+    }
+  }
+  add(sessionID) {
+    this.#ids.delete(sessionID);
+    this.#ids.add(sessionID);
+    while (this.#ids.size > this.limit) {
+      const oldest = this.#ids.values().next().value;
+      if (oldest === undefined)
+        break;
+      this.#ids.delete(oldest);
+    }
+  }
+  has(sessionID) {
+    return this.#ids.has(sessionID);
+  }
+  clear() {
+    this.#ids.clear();
+  }
+  get size() {
+    return this.#ids.size;
+  }
 }
 
 // src/v2/hooks/generate.ts
@@ -20433,9 +21270,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash6 } from "node:crypto";
-function identity(slot) {
-  return createHash6("sha256").update(JSON.stringify({
+import { createHash as createHash7 } from "node:crypto";
+function identity2(slot) {
+  return createHash7("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -20450,14 +21287,14 @@ class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
   capture(sessionId, slot, input, served) {
     this.systems.set(sessionId, {
-      slot: identity(slot),
+      slot: identity2(slot),
       input: JSON.stringify(input),
       served: structuredClone(served)
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
+    if (!slot || !saved || saved.slot !== identity2(slot) || saved.input !== JSON.stringify(input))
       return false;
     target.splice(0, target.length, ...structuredClone(saved.served));
     return true;
@@ -20642,7 +21479,7 @@ function hasRequiredSessionAPI(session) {
 }
 
 // src/features/magic-context/session-project-backfill.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
 var LEASE_TTL_MS = 10 * 60 * 1000;
 var SESSION_PAGE_SIZE = 100;
@@ -20784,7 +21621,7 @@ async function runSessionProjectBackfill(db, source, options = {}) {
   const now = options.now ?? Date.now;
   const resolveIdentity = options.resolveIdentity ?? ((directory) => resolveProjectIdentityForSession(directory, options.allowHomeProject));
   const yieldFn = options.yieldFn ?? defaultYieldFn;
-  const holderId = options.holderId ?? randomUUID2();
+  const holderId = options.holderId ?? randomUUID4();
   const readPage = createPageReader(source);
   const result = {
     status: "completed",
@@ -21377,7 +22214,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -21466,7 +22303,7 @@ function reasoningOf(part) {
 function renderPartPreview(part, expandTools) {
   if (!isRecord4(part))
     return null;
-  const expansion = expandToolPart(part, expandTools);
+  const expansion = expandToolPart(part, expandTools, true);
   if (expansion !== null)
     return `    • tool ${part.tool}: ${expansion}`;
   const text = textOf(part);
@@ -21601,7 +22438,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" && createHash7("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash8("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   return selected ? renderPartFull(selected) ?? "" : `Tag ${number}'s original text part is no longer in stored history.`;
 }
@@ -22912,6 +23749,9 @@ function persistV2UsageReading(args) {
 
 // src/v2/hooks/context.ts
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
+
+class V2LkgAdmissionReplay extends Error {
+}
 function isBlockingV2TransformError(error) {
   return error instanceof EmergencyFailClosedError || error instanceof UnresolvedHistoryBoundaryError || error instanceof UnmanagedOverWindowError || error instanceof DegradedPassRefusalError || isFailClosedBlockingError(error);
 }
@@ -23120,6 +23960,8 @@ async function registerContext(context) {
     return;
   }
   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;
   setOutputReserveConfig(config.output_reserve);
   const queriedModels = new Set;
   const rawLimits = new Map;
@@ -23151,7 +23993,7 @@ async function registerContext(context) {
   let storageRecoveryAnnounced = false;
   const storageNoticeBySession = new Map;
   const storeStorageNotice = (sessionID, text, what) => {
-    withoutSqliteTransformPass(() => context.session.wait({ sessionID }).then(() => deliverSynthetic(context, sessionID, text)).catch((error) => sessionLog(sessionID, `v2 storage ${what} notice could not be delivered:`, error)));
+    withoutSqliteTransformPass(() => Promise.resolve().then(() => context.session.wait({ sessionID })).then(() => deliverSynthetic(context, sessionID, text)).catch((error) => sessionLog(sessionID, `v2 storage ${what} notice could not be delivered:`, error)));
   };
   const noticeStorageRefusal = (sessionID, reason) => {
     const message = formatStorageRefusalNotice(reason);
@@ -23418,6 +24260,14 @@ async function registerContext(context) {
     }
     return unsafe;
   };
+  const hostFolds = nativeFoldReplay && nativeFoldMemory ? new HostFoldPolicy({
+    session: context.session,
+    storage: nativeFoldMemory,
+    openReader: openStoreReader,
+    canReplay: (sessionID, reader) => nativeFoldReplay.canReplay(sessionID, reader),
+    threshold: Number(process.env.MMC_OC2_HOST_FOLD_ROWS ?? 1000),
+    log: sessionLog
+  }) : undefined;
   const usageController = new AbortController;
   const usageDone = (async () => {
     try {
@@ -23428,6 +24278,10 @@ async function registerContext(context) {
         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.error" || event.type === "session.execution.failed") {
           const error = hiddenTerminalError(event);
           if (error !== undefined)
@@ -23453,6 +24307,7 @@ async function registerContext(context) {
           pendingMaterializationSessions.delete(sessionID);
           lastHeuristicsTurnId.delete(sessionID);
           restoredRows.forget(sessionID);
+          await nativeFoldReplay?.forget(sessionID);
           generateReplay.forget(sessionID);
           systemPromptRefreshSessions.delete(sessionID);
           systemPrompt?.clearSession(sessionID);
@@ -23465,11 +24320,14 @@ async function registerContext(context) {
         if (event.type !== "session.execution.succeeded")
           continue;
         const model = liveModels.get(sessionID);
-        if (model)
+        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)
@@ -23504,10 +24362,32 @@ async function registerContext(context) {
     }
     if (compactionOff)
       return;
+    if (nativeFoldReplay)
+      rememberHostMedia(draft.messages);
     const reader = openStoreReader();
     try {
       const watermark = reader.latestSequenceForIds(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
       const running = reader.latestRunningCompaction(draft.sessionID);
+      if (nativeFoldReplay) {
+        try {
+          if (await nativeFoldReplay.canReplay(draft.sessionID, reader)) {
+            const state = getOrCreateSessionMeta(storage.require(), draft.sessionID);
+            const summary = await nativeFoldReplay.baseline(draft.sessionID) ?? state.cachedM0Bytes?.toString("utf8") ?? "<session-history></session-history>";
+            if (await nativeFoldReplay.supply({
+              draft,
+              reader,
+              previousCut: reader.latestCompaction(draft.sessionID),
+              summary
+            })) {
+              draft.result = { summary };
+              return;
+            }
+          }
+        } catch (error) {
+          nativeFoldReplay.invalidate(draft.sessionID, true);
+          sessionLog(draft.sessionID, `v2 host fold: legacy compaction reason=${JSON.stringify(String(error))}`);
+        }
+      }
       const fold = await folds.supply({
         sessionID: draft.sessionID,
         watermark,
@@ -23554,12 +24434,88 @@ async function registerContext(context) {
       withoutSqliteTransformPass(() => warmModelLimitCacheFromCatalog(context));
     agents.set(draft.sessionID, draft.agent);
     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))
+        return false;
+      const limit = lkgReplayLimit({
+        db: admissionDb,
+        sessionId: draft.sessionID,
+        model: {
+          providerID: draft.model.providerID,
+          modelID: draft.model.id
+        },
+        modelKey: `${draft.model.providerID}/${draft.model.id}`
+      });
+      if (limit === undefined)
+        return false;
+      let toolDefinitionTokens = 0;
+      for (const tool of Object.values(draft.tools)) {
+        if (!tool || typeof tool.description !== "string" || !tool.input)
+          return false;
+        const schema = JSON.stringify(tool.input);
+        if (!schema)
+          return false;
+        toolDefinitionTokens += estimateTokens(tool.description) + estimateTokens(schema);
+      }
+      return measureLkgReplay({
+        messages,
+        limit,
+        estimate: () => estimateFinalWireInputTokens({
+          messages,
+          toolDefinitionTokens,
+          systemPromptTokens: estimateTokens(JSON.stringify(system)),
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agentName: draft.agent
+        })
+      }).fit === "under";
+    };
     let postFold = false;
     try {
-      const admissionDb = db ?? storage.current();
       if (!compactionOff && admissionDb)
         await withAsyncPrivilegedWriter(admissionDb, () => {
           return;
+        }, {
+          beforeRetry: (_error) => {
+            let replayBlocked = false;
+            const mapped = adaptPayload(draft);
+            try {
+              const overflowDb = db;
+              if (overflowDb !== undefined && overflowDb !== null && (isEmergencyRecoveryArmed(draft.sessionID) || getOverflowState(overflowDb, draft.sessionID).needsEmergencyRecovery)) {
+                replayBlocked = true;
+                sessionLog(draft.sessionID, "lkg_emergency_armed");
+              } else {
+                const keys = resolveLkgModelKeys(mapped.messages);
+                const replay = replayLkg({
+                  sessionId: draft.sessionID,
+                  messages: mapped.messages,
+                  modelKey: keys.modelKey,
+                  providerKey: keys.providerKey
+                });
+                if (replay.ok && !replayFits(replay.messages)) {
+                  replayBlocked = true;
+                  sessionLog(draft.sessionID, "lkg_replay_does_not_fit");
+                } else if (replay.ok) {
+                  restoreLkgSystem();
+                  mapped.messages.splice(0, mapped.messages.length, ...replay.messages);
+                  mapped.commit();
+                  sessionLog(draft.sessionID, "lkg_replay_served");
+                  throw new V2LkgAdmissionReplay;
+                } else {
+                  sessionLog(draft.sessionID, replay.reason);
+                }
+              }
+            } catch (replayError) {
+              if (replayError instanceof V2LkgAdmissionReplay)
+                throw replayError;
+              replayBlocked = true;
+              sessionLog(draft.sessionID, "lkg_replay_unavailable", replayError);
+            }
+            if (replayBlocked)
+              sessionLog(draft.sessionID, "lkg_replay_declined");
+          }
         });
       if (admissionDb)
         hideSubagentTools(draft, admissionDb);
@@ -23714,7 +24670,28 @@ async function registerContext(context) {
         postFold = cut !== undefined;
         if (cut && !incoming)
           throw new Error("The host checkpoint disappeared from the context draft");
-        if (cut && incoming) {
+        let nativeRestored;
+        if (cut && nativeFoldReplay && isLocalCheckpoint(cut)) {
+          try {
+            nativeRestored = await nativeFoldReplay.restore(draft.sessionID, cut, `${draft.model.providerID}/${draft.model.id}`, { bounded: true });
+          } catch (error) {
+            nativeFoldReplay.invalidate(draft.sessionID, true);
+            sessionLog(draft.sessionID, "v2 host fold: cache unavailable; restoring host rows", error);
+            nativeRestored = await nativeFoldReplay.restoreRead(draft.sessionID, cut, draft.model);
+          }
+        }
+        if (nativeRestored && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
+          historyRefreshSessions.add(draft.sessionID);
+          pendingMaterializationSessions.add(draft.sessionID);
+        }
+        if (cut && incoming && nativeRestored) {
+          const present = new Set(draft.messages.flatMap((message) => message.id ? [message.id] : []));
+          const hidden = nativeRestored.filter((message) => {
+            const id = nativeRowID(message);
+            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,
@@ -23741,6 +24718,14 @@ async function registerContext(context) {
       } finally {
         reader.close();
       }
+      let nativeMessages;
+      if (nativeFoldReplay) {
+        try {
+          nativeMessages = copyNativeInput(draft.messages);
+        } catch {
+          nativeFoldReplay.invalidate(draft.sessionID, true);
+        }
+      }
       const mapped = adaptPayload(draft, admitted);
       beginV2LkgRequest(draft.sessionID, `${draft.model.providerID}/${draft.model.id}`, latestLkgResponseIds.get(draft.sessionID));
       await transform({}, mapped);
@@ -23766,6 +24751,14 @@ ${baseline}
           draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
         }
       }
+      if (nativeMessages && !checkpoint) {
+        try {
+          await nativeFoldReplay?.capture(draft, nativeMessages);
+        } catch (error) {
+          nativeFoldReplay?.invalidate(draft.sessionID, true);
+          sessionLog(draft.sessionID, "v2 host fold: optional capture unavailable", error);
+        }
+      }
       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);
@@ -23773,6 +24766,8 @@ ${baseline}
     } catch (error) {
       if (error instanceof V2ContextRefusal)
         throw error;
+      if (error instanceof V2LkgAdmissionReplay)
+        return;
       if (!compactionOff && (isTransientSqliteError(error) || error instanceof StorageBusyRefusalError)) {
         if (isTransientSqliteError(error)) {
           try {
@@ -23800,13 +24795,16 @@ ${baseline}
                 modelKey: keys.modelKey,
                 providerKey: keys.providerKey
               });
-              if (replay.ok) {
+              if (replay.ok && !replayFits(replay.messages)) {
+                sessionLog(draft.sessionID, "lkg_replay_does_not_fit");
+              } else if (replay.ok) {
                 restoreLkgSystem();
                 replayMapped.messages.splice(0, replayMapped.messages.length, ...replay.messages);
                 replayMapped.commit();
                 return;
+              } else {
+                sessionLog(draft.sessionID, replay.reason);
               }
-              sessionLog(draft.sessionID, replay.reason);
             }
           } catch (replayError) {
             replayBlocked = true;