@retaw106/mmc-oc 2.0.0 → 2.1.1

package/dist/{context-95zkksn3.js → context-cx3y8abt.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;
     }
@@ -13442,6 +13619,8 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
           continue;
         const strippedSource = stripTagPrefix(stripped);
         if (strippedSource.trim().length === 0) {
+          if (target.thinkingDropProtected)
+            continue;
           const dropResult = target.drop?.() ?? "absent";
           const replacement = `[dropped §${tag.tagNumber}§]`;
           const didReplace = dropResult === "absent" ? target.setContent(replacement) : false;
@@ -15833,19 +16012,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 +16047,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 +16067,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 +16081,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 +16636,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 +18052,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 +18102,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 +18843,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 +18864,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 +18872,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 +18913,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,1609 +18998,2235 @@ 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")
-          ].filter((line) => line !== undefined).join(`
-`)}`,
-          metadata: {
-            attachment: {
-              source: file.source,
-              name: file.name,
-              description: file.description
-            }
-          }
-        }
-      ];
-    }
-    if (!imageMimes.has(file.mime) && file.mime !== "application/pdf")
-      return [];
-    const metadata = file.description === undefined ? undefined : { description: file.description };
-    const located = location ? [{ type: "text", text: `Attached file: ${location}` }] : [];
-    if (!media)
-      return [
-        ...located,
-        {
-          type: "media",
-          mediaType: file.mime,
-          data: file.data,
-          filename: file.name,
-          metadata
-        }
-      ];
-    const asset = media.asset(file.data, file.mime);
-    if (typeof asset === "string") {
-      media.unavailable({ rowID, name: file.name, mediaType: file.mime, reason: asset });
-      return [
-        ...located,
-        { type: "text", text: unavailableAttachmentNote(file.name, file.mime) }
-      ];
+    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 [...located, { type: "media", media: asset, filename: file.name, metadata }];
-  });
+    return entry;
+  };
+  return JSON.stringify(plain(value));
 }
-function restoreRow(row, model, media) {
-  const data = row.data;
-  const make = (role, content, metadata = data.metadata) => ({
-    id: row.id,
-    role,
-    content,
-    ...metadata === undefined ? {} : { metadata }
-  });
-  if (row.type === "user") {
-    const skills = data.skills ?? [];
-    const content = [
-      ...skills.flatMap((skill) => skill.text === undefined ? [] : [{ type: "text", text: skill.text }]),
-      ...data.text ? [{ type: "text", text: data.text }] : [],
-      ...attachmentParts(data.files ?? [], row.id, media)
-    ];
-    return content.length ? [
-      make("user", content, {
-        ...data.metadata ?? {},
-        ...data.agents?.length ? { agents: data.agents } : {}
-      })
-    ] : [];
-  }
-  if (row.type === "system")
-    return [{ role: "system", content: [{ type: "text", text: data.text ?? "" }] }];
-  if (row.type === "synthetic" && isStorageNoticeText(data.text))
-    return [];
-  if (["synthetic", "skill"].includes(row.type))
-    return [make("user", [{ type: "text", text: data.text ?? "" }])];
-  if (row.type === "location-switched")
-    return [
-      make("user", [
-        {
-          type: "text",
-          text: `The working directory has been changed to ${data.location.directory}.`
-        }
-      ])
-    ];
-  if (row.type === "shell")
-    return data.metadata?.background === true ? [] : [
-      make("user", [
-        {
-          type: "text",
-          text: `The following shell command was executed by the user:
-
-Command:
-${data.command}
-
-Output:
-${data.output?.output ?? ""}`
-        }
-      ])
-    ];
-  if (row.type !== "assistant")
-    return [];
-  const previousModel = data.model;
-  const sameProvider = previousModel?.providerID === model.providerID;
-  const sameModel = sameProvider && previousModel?.id === model.id;
-  const reuse = sameModel && data.error === undefined;
-  const metadata = (state) => state === undefined ? undefined : { [model.providerID]: state };
-  const content = [];
-  const results = [];
-  for (const part of data.content ?? []) {
-    if (part.type === "text") {
-      if (part.text !== "")
-        content.push({
-          type: "text",
-          text: part.text,
-          providerMetadata: reuse ? metadata(part.state) : undefined
-        });
-      continue;
-    }
-    if (part.type === "reasoning") {
-      if (part.text !== "" || reuse && part.state !== undefined)
-        content.push({
-          type: reuse || data.error === undefined ? "reasoning" : "text",
-          text: part.text,
-          providerMetadata: reuse ? metadata(part.state) : undefined
-        });
+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;
     }
-    const state = part.state;
-    const completed = state.status === "completed" || state.status === "error";
-    const toolReuse = reuse || sameModel && part.executed === true && completed;
-    let input = state.input;
-    if (state.status === "streaming" && typeof input === "string") {
-      try {
-        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)
+    if (placed)
       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] });
+    placed = true;
+    rebuilt.push({ ...item, text: output });
   }
-  return [...content.length ? [make("assistant", content)] : [], ...results];
-}
-
-// src/v2/fork-inheritance.ts
-var RAW_TYPES = new Set(RAW_MESSAGE_TYPES);
-function forkBoundarySeq(origin, sequenceForId) {
-  const seq = sequenceForId(origin.parentSessionID, origin.boundary.messageID);
-  if (seq === undefined)
-    return;
-  return origin.boundary.type === "before" ? seq - 1 : seq;
+  if (!placed && output)
+    rebuilt.unshift({ type: "text", text: output });
+  return { type: "content", value: rebuilt };
 }
-function buildForkIdMap(parentRows, forkRows, throughSeq) {
-  const parentBySeq = new Map;
-  for (const row of parentRows)
-    if (row.seq <= throughSeq)
-      parentBySeq.set(row.seq, row);
-  const parentToFork = new Map;
-  const forkOrdinals = new Map;
-  let ordinal = 0;
-  for (const row of forkRows) {
-    if (row.seq > throughSeq)
-      break;
-    if (RAW_TYPES.has(row.type)) {
-      ordinal += 1;
-      forkOrdinals.set(row.id, ordinal);
-    }
-    const parent = parentBySeq.get(row.seq);
-    if (parent && parent.type === row.type && parent.time_created === row.time_created && row.id !== parent.id && row.id.endsWith(`_${row.seq}`)) {
-      parentToFork.set(parent.id, row.id);
+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 parentOrdinals = new Map;
-  let parentOrdinal = 0;
-  for (const row of parentRows) {
-    if (row.seq > throughSeq)
-      break;
-    if (!RAW_TYPES.has(row.type))
-      continue;
-    parentOrdinal += 1;
-    parentOrdinals.set(parentOrdinal, row.id);
-  }
-  return { parentToFork, forkOrdinals, parentOrdinals, throughSeq };
-}
-var CONTENT_ID_SUFFIX = /(:(?:p|file)\d+)$/;
-var BLOCK_ID_SUFFIX = /(#\d+)$/;
-function splitMessageScopedId(id) {
-  const match = id.match(CONTENT_ID_SUFFIX) ?? id.match(BLOCK_ID_SUFFIX);
-  if (!match?.[1])
-    return { messageId: id, suffix: "" };
-  return { messageId: id.slice(0, -match[1].length), suffix: match[1] };
-}
-function forkCloneFilter(idMap, copiedToolCallIds) {
-  const mapMessageScoped = (id) => {
-    const direct = idMap.parentToFork.get(id);
-    if (direct)
-      return direct;
-    const { messageId, suffix } = splitMessageScopedId(id);
-    if (!suffix)
-      return;
-    const mapped = idMap.parentToFork.get(messageId);
-    return mapped ? `${mapped}${suffix}` : undefined;
-  };
-  return {
-    resolveBoundaryOrdinal: (messageId) => {
-      const forkId = idMap.parentToFork.get(messageId);
-      return forkId ? idMap.forkOrdinals.get(forkId) : undefined;
-    },
-    includeMessageId: (messageId) => mapMessageScoped(messageId) !== undefined || copiedToolCallIds.has(messageId),
-    mapMessageId: (messageId) => mapMessageScoped(messageId) ?? messageId,
-    includeTag: (tag) => {
-      if (tag.type === "tool") {
-        return tag.toolOwnerMessageId !== null && idMap.parentToFork.has(tag.toolOwnerMessageId);
-      }
-      return mapMessageScoped(tag.messageId) !== undefined;
-    },
-    mapOrdinal: (sourceOrdinal) => {
-      const parentId = idMap.parentOrdinals.get(sourceOrdinal);
-      const forkId = parentId ? idMap.parentToFork.get(parentId) : undefined;
-      return forkId ? idMap.forkOrdinals.get(forkId) : undefined;
-    },
-    copySessionNotesAndFacts: true,
-    selectPendingPiMarker: () => null
-  };
-}
-function countSessionRows(db, table, sessionId) {
-  const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE session_id = ?`).get(sessionId);
-  return typeof row?.count === "number" ? row.count : 0;
-}
-function sessionHasMagicContextState(db, sessionId) {
-  return countSessionRows(db, "compartments", sessionId) > 0 || countSessionRows(db, "tags", sessionId) > 0;
-}
-function seedV2ForkFromParent(args) {
-  const { db, store, sessionId } = args;
-  if (sessionHasMagicContextState(db, sessionId))
-    return { kind: "has-state" };
-  const origin = store.forkOrigin(sessionId);
-  if (!origin)
-    return { kind: "not-a-fork" };
-  const parentSessionID = origin.parentSessionID;
-  if (parentSessionID === sessionId)
-    return { kind: "not-a-fork" };
-  if (!sessionHasMagicContextState(db, parentSessionID))
-    return { kind: "parent-missing", parentSessionID, reason: "no Magic Context state" };
-  if (!store.sessionExists(parentSessionID))
-    return { kind: "parent-missing", parentSessionID, reason: "no host session row" };
-  const throughSeq = forkBoundarySeq(origin, (session, id) => store.sequenceForId(session, id));
-  if (throughSeq === undefined)
-    return { kind: "parent-missing", parentSessionID, reason: "boundary row not in the store" };
-  const idMap = buildForkIdMap(store.rowStampsThrough(parentSessionID, throughSeq), store.rowStampsThrough(sessionId, throughSeq), throughSeq);
-  if (idMap.parentToFork.size === 0)
-    return { kind: "parent-missing", parentSessionID, reason: "no copied rows pair up" };
-  const toolTags = db.prepare("SELECT message_id, tool_owner_message_id FROM tags WHERE session_id = ? AND type = 'tool'").all(parentSessionID);
-  const copiedToolCallIds = new Set(toolTags.filter((row) => row.tool_owner_message_id !== null && idMap.parentToFork.has(row.tool_owner_message_id)).map((row) => row.message_id));
-  const result = copySessionStateForClone(db, parentSessionID, sessionId, forkCloneFilter(idMap, copiedToolCallIds));
-  if (result.kind === "destination-not-empty")
-    return { kind: "destination-not-empty", parentSessionID };
-  return { kind: "seeded", parentSessionID, pairedRows: idMap.parentToFork.size, result };
-}
-
-// src/v2/hidden-child-record.ts
-function keptUnderRetention(keepSubagents, child) {
-  return keepSubagents && (child.ever_settled === true || child.role === "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";
-}
-function roleAgent(role) {
-  if (role === "maintainer-a")
-    return MEMORY_MAINTAINER_A_AGENT;
-  if (role === "maintainer-b")
-    return MEMORY_MAINTAINER_B_AGENT;
-  return HIDDEN_HISTORIAN_AGENT;
-}
-function childCreateInput(identity, role, model) {
-  const agent = roleAgent(role);
-  return {
-    title: roleTitle(role),
-    agent,
-    model: {
-      providerID: model.providerID,
-      id: model.modelID,
-      ...model.variant ? { variant: model.variant } : {}
-    },
-    location: { directory: identity.directory },
-    metadata: { magic_context: "hidden-run", role },
-    permissions: hiddenChildPermissions(agent)
-  };
-}
-function assistantOutcome(row) {
-  const outcome = row?.data.outcome;
-  return outcome === "succeeded" || outcome === "failed" || outcome === "interrupted" ? outcome : undefined;
-}
-function withReader(openReader, read) {
-  const reader = openReader();
-  try {
-    return read(reader);
-  } finally {
-    reader.close?.();
-  }
-}
-function errorText(value) {
-  if (value instanceof Error)
-    return value.message;
-  if (typeof value === "string")
-    return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-// src/v2/hidden-child-native.ts
-function nativeSessionRemove(session) {
-  const remove = session.remove;
-  if (typeof remove !== "function")
-    return;
-  return (input) => Promise.resolve(remove.call(session, { sessionID: input.sessionID }));
-}
-function isSessionNotFound(error) {
-  if (!error || typeof error !== "object")
-    return false;
-  const fields = error;
-  if (fields.status === 404)
-    return true;
-  const label = [fields.name, fields._tag, fields.message].filter((value) => typeof value === "string").join(" ");
-  return /not\s*found/i.test(label);
-}
-var parentDroppedNoted = false;
-function createNativeHiddenChildren(host, removeSession, options) {
-  const removing = new Map;
-  const remove = (child) => {
-    const inFlight = removing.get(child.id);
-    if (inFlight)
-      return inFlight;
-    const done = (async () => {
-      try {
-        let timer;
-        try {
-          await Promise.race([
-            removeSession({ sessionID: child.id }),
-            new Promise((_, reject) => {
-              timer = setTimeout(() => reject(new Error("session.remove timed out")), options.removalTimeoutMs ?? 5000);
-            })
-          ]);
-        } finally {
-          if (timer)
-            clearTimeout(timer);
-        }
-      } catch (error) {
-        if (isSessionNotFound(error))
-          return;
-        options.log(`[magic-context] hidden child ${child.id} could not be removed; it goes when its parent session is deleted: ${errorText(error)}`);
+  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) } : {}
       }
-    })().finally(() => {
-      removing.delete(child.id);
+    };
+    bridges.set(part, {
+      call,
+      result: result?.part,
+      resultMessage: result?.message,
+      output,
+      files
     });
-    removing.set(child.id, done);
-    return done;
-  };
-  const confirmPlacement = async (sessionID, parentID) => {
-    let stored;
-    try {
-      stored = await host.get({ sessionID });
-    } catch (error) {
-      options.log(`[magic-context] could not read back hidden child ${sessionID} to confirm its parent: ${errorText(error)}`);
-      return;
-    }
-    const directory = stored.location?.directory;
-    if (options.directory !== undefined && directory !== undefined && directory !== options.directory) {
-      throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", `hidden child ${sessionID} is bound to ${directory}, not to this instance's ${options.directory}`, true);
-    }
-    if (stored.parentID === parentID || parentDroppedNoted)
-      return;
-    parentDroppedNoted = true;
-    options.log(`[magic-context] this OpenCode 2 host does not keep the parent of hidden-run sessions (asked for ${parentID}, read back ${stored.parentID ?? "none"}); they are created as separate sessions and still removed when each run ends`);
+    if (result)
+      paired.add(result.part);
+    return part;
   };
-  const create = async (identity, role, model) => {
-    const parentID = identity.parentSessionId;
-    const input = childCreateInput(identity, role, model);
-    const { location, ...parented } = input;
-    const created = await host.create(parentID ? { ...parented, parentID } : { ...parented, location });
-    if (!created.id)
-      throw new Error("OpenCode 2 did not return a child session id");
-    options.hook.registerChild(created.id, input.agent);
-    const child = {
-      id: created.id,
-      role,
-      generation: options.generation,
-      title: roleTitle(role),
-      model,
-      created_at: Date.now(),
-      directory: identity.directory
+  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 }
     };
-    if (parentID) {
-      try {
-        await confirmPlacement(created.id, parentID);
-      } catch (error) {
-        await remove(child);
-        throw error;
+    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));
       }
     }
-    return child;
-  };
-  const kept = (child) => keptUnderRetention(options.keepSubagents, child);
-  return {
-    open: create,
-    create,
-    retire(child) {
-      if (!kept(child))
-        remove(child);
-    },
-    async finish(child, retired) {
-      if (retired) {
-        await removing.get(child.id);
-        return;
-      }
-      if (!kept(child))
-        await remove(child);
-    },
-    updateModel: (child, model) => ({ ...child, model }),
-    markEverSettled: (child) => ({ ...child, ever_settled: true })
-  };
-}
-
-// src/v2/hidden-child-cleanup.ts
-var PREFIX = "opencode2_hidden_children:";
-var COMPLETE = "opencode2_hidden_children_cleanup_complete";
-async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
-  if (db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key = ?").get(COMPLETE))
-    return;
-  const rows = db.prepare("SELECT key, value FROM schema_migrations_meta WHERE key GLOB ? ORDER BY key LIMIT 25").all(`${PREFIX}*`);
-  let remaining = options.limit ?? 25;
-  const now = options.now ?? (() => performance.now());
-  const deadline = now() + (options.budgetMs ?? 2000);
-  for (const row of rows) {
-    let record;
-    try {
-      record = JSON.parse(row.value);
-      if (!record || typeof record !== "object" || record.active !== undefined && (!record.active || typeof record.active !== "object" || Array.isArray(record.active)) || record.retired_children !== undefined && !Array.isArray(record.retired_children))
-        throw new Error("invalid record");
-    } catch {
-      note(`[magic-context] legacy hidden-child cleanup cannot read ${row.key}`);
+  }
+  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);
     }
-    const children = [
-      ...Object.values(record.active ?? {}),
-      ...record.retired_children ?? []
-    ];
-    for (const child of children) {
-      if (remaining-- <= 0 || now() >= deadline)
-        return;
-      if (typeof child?.id !== "string") {
-        note(`[magic-context] legacy hidden-child cleanup has an invalid child in ${row.key}`);
-        continue;
-      }
-      let timer;
-      try {
-        try {
-          await Promise.race([
-            remove({ sessionID: child.id }),
-            new Promise((_, reject) => {
-              timer = setTimeout(() => reject(new Error("session.remove timed out")), Math.min(options.timeoutMs ?? 1000, Math.max(1, deadline - now())));
-            })
-          ]);
-        } catch (error) {
-          if (!isSessionNotFound(error))
-            throw error;
+    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
         }
-        record.active = Object.fromEntries(Object.entries(record.active ?? {}).filter(([, entry]) => entry.id !== child.id));
-        record.retired_children = (record.retired_children ?? []).filter((entry) => entry.id !== child.id);
-        db.prepare("UPDATE schema_migrations_meta SET value = ? WHERE key = ?").run(JSON.stringify(record), row.key);
-      } catch (error) {
-        note(`[magic-context] legacy hidden child ${child.id} cleanup deferred: ${String(error)}`);
-      } finally {
-        if (timer)
-          clearTimeout(timer);
+      },
+      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);
     }
-    if (Object.keys(record.active ?? {}).length === 0 && (record.retired_children ?? []).length === 0)
-      db.prepare("DELETE FROM schema_migrations_meta WHERE key = ?").run(row.key);
-  }
-  if (!db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key GLOB ? LIMIT 1").get(`${PREFIX}*`))
-    db.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, 'true')").run(COMPLETE);
+  };
 }
 
-// src/v2/hidden-completion.ts
-var POLL_INTERVAL_MS = 200;
-function modelKey(model) {
-  return `${model.providerID}/${model.modelID}`;
+// src/v2/fold/native-codec.ts
+class NativeReplayUnavailable extends Error {
 }
-function sameModel(left, right) {
-  return modelKey(left) === modelKey(right) && left.variant === right.variant;
+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 configuredHead(identity) {
-  const candidates = [identity.model, ...identity.configuredModels ?? []];
-  for (const candidate of candidates) {
-    const entry = toModelEntry(candidate);
-    const parsed = entry ? parseProviderModel(entry.model) : null;
-    if (parsed)
-      return { ...parsed, ...entry?.qualifier ? { variant: entry.qualifier } : {} };
-  }
-  return;
-}
-var HIDDEN_MAINTAINER_ROLES = {
-  "maintainer-a": "magic-context-maintainer-a",
-  "maintainer-b": "magic-context-maintainer-b"
-};
-function roleFor(identity) {
-  for (const [role, agent] of Object.entries(HIDDEN_MAINTAINER_ROLES)) {
-    if (identity.agent === agent)
-      return role;
-  }
-  return "historian";
-}
-function promptText(request) {
-  const parts = request.body.parts;
-  return Array.isArray(parts) ? parts.flatMap((part) => part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []).join(`
-`) : "";
+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;
 }
-function meter(system, prompt, text) {
-  return {
-    input: estimateTokens(system) + estimateTokens(prompt),
-    output: estimateTokens(text),
-    cacheRead: 0,
-    cacheWrite: 0
-  };
+
+// 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 assistantReasoning(row) {
-  const reasoning = (row.data.content ?? []).flatMap((part) => part.type === "reasoning" && typeof part.text === "string" ? [part.text] : []).join(`
-`);
-  return reasoning.length > 0 ? reasoning : null;
+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 assistantText(row) {
-  const text = (row.data.content ?? []).flatMap((part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("");
-  return text.length > 0 ? text : null;
+function isStorageNoticeText(text) {
+  return typeof text === "string" && text.startsWith(STORAGE_NOTICE_PREFIX);
 }
-
-class HiddenProviderError extends Error {
-  settled;
-  constructor(detail, options = {}) {
-    super(`Hidden completion provider error: ${detail}`);
-    this.name = "HiddenProviderError";
-    this.settled = options.settled ?? true;
-  }
+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);
 }
-function requestModel(request, current) {
-  const requested = request.body.model;
-  if (requested && typeof requested.providerID === "string" && typeof requested.modelID === "string") {
-    return {
-      providerID: requested.providerID,
-      modelID: requested.modelID,
-      ...typeof request.body.variant === "string" ? { variant: request.body.variant } : {}
-    };
+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);
   }
-  return current;
-}
-async function sleepUntilPoll(signal, deadline) {
-  if (signal?.aborted)
-    throw new Error("Hidden completion prompt aborted");
-  const delay = Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now()));
-  if (delay <= 0)
-    return;
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(resolve, delay);
-    const abort = () => {
-      clearTimeout(timer);
-      reject(new Error("Hidden completion prompt aborted"));
-    };
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted)
-      abort();
-    else
-      setTimeout(() => {
-        signal?.removeEventListener("abort", abort);
-      }, delay);
-  });
+  if (drop.size === 0)
+    return 0;
+  const kept = messages.filter((message) => !drop.has(message));
+  messages.splice(0, messages.length, ...kept);
+  return drop.size;
 }
-function isProviderFailure(error) {
-  if (!error || typeof error !== "object")
-    return false;
-  const type = error.type;
-  return typeof type === "string" && (type.startsWith("provider.") || type.toLowerCase().includes("provider"));
+
+// src/v2/fold/restore.ts
+function unavailableAttachmentNote(name, mediaType) {
+  return `[Attachment ${name ? `"${name}" ` : ""}(${mediaType}) is not available in this restored history]`;
 }
-async function awaitAssistantRow(openReader, readSessionError, localFailure, childID, afterSeq, deadline, signal) {
-  for (;; ) {
-    const { assistant, idle } = withReader(openReader, (reader) => ({
-      assistant: reader.latestAssistant(childID),
-      idle: reader.latestIdle(childID)
-    }));
-    const newAssistant = assistant && assistant.seq > afterSeq ? assistant : undefined;
-    const newIdle = idle && idle.seq > afterSeq ? idle : undefined;
-    const refused = localFailure();
-    if (refused)
-      throw refused;
-    if (newIdle && (!newAssistant || newIdle.seq > newAssistant.seq)) {
-      const outcome = newIdle.data.outcome;
-      if (outcome === "failed" || outcome === "interrupted") {
-        const sessionError = await readSessionError();
-        const details = [
-          `outcome=${outcome}`,
-          `terminal_row=${errorText(newIdle)}`,
-          `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
-        ];
-        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
-      }
-      if (outcome === "succeeded" && newAssistant)
-        return newAssistant;
+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);
     }
-    if (newAssistant) {
-      const outcome = assistantOutcome(newAssistant);
-      if (outcome === "failed" || outcome === "interrupted") {
-        const sessionError = await readSessionError();
-        const details = [
-          `outcome=${outcome}`,
-          `terminal_row=${errorText(newAssistant)}`,
-          `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
-        ];
-        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
-      }
-      if (newAssistant.data.error !== undefined) {
-        throw new HiddenProviderError(errorText(newAssistant.data.error), {
-          settled: typeof newAssistant.data.finish === "string"
-        });
-      }
-      if (typeof newAssistant.data.finish === "string" || outcome === "succeeded") {
-        return newAssistant;
-      }
+    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: {
+            attachment: {
+              source: file.source,
+              name: file.name,
+              description: file.description
+            }
+          }
+        }
+      ];
     }
-    if (Date.now() >= deadline) {
-      throw new Error("Hidden completion timed out waiting for a persisted assistant row");
+    if (!imageMimes.has(file.mime) && file.mime !== "application/pdf")
+      return [];
+    const metadata = file.description === undefined ? undefined : { description: file.description };
+    const located = location ? [{ type: "text", text: `Attached file: ${location}` }] : [];
+    if (!media)
+      return [
+        ...located,
+        {
+          type: "media",
+          mediaType: file.mime,
+          data: file.data,
+          filename: file.name,
+          metadata
+        }
+      ];
+    const asset = media.asset(file.data, file.mime);
+    if (typeof asset === "string") {
+      media.unavailable({ rowID, name: file.name, mediaType: file.mime, reason: asset });
+      return [
+        ...located,
+        { type: "text", text: unavailableAttachmentNote(file.name, file.mime) }
+      ];
     }
-    await sleepUntilPoll(signal, deadline);
-  }
-}
-var V2_HIDDEN_EXECUTOR_CAPABILITIES = {
-  tools: true,
-  harness: "opencode2"
-};
-function createLateHiddenExecutor(current) {
-  const wired = () => {
-    const executor = current();
-    if (executor)
-      return executor;
-    throw new Error("Magic Context hidden work is unavailable until the context database opens.");
-  };
-  return {
-    get capabilities() {
-      return current()?.capabilities ?? V2_HIDDEN_EXECUTOR_CAPABILITIES;
-    },
-    open: (run) => wired().open(run),
-    attempt: (handle, request) => wired().attempt(handle, request),
-    collect: (handle, limit) => wired().collect(handle, limit),
-    close: (handle, settlement) => wired().close(handle, settlement)
-  };
+    return [...located, { type: "media", media: asset, filename: file.name, metadata }];
+  });
 }
-async function createV2HiddenCompletionExecutor(host, options) {
-  const runs = new WeakMap;
-  const generation = options.generation ?? "opencode2";
-  const roleTails = new Map;
-  const note = options.log ?? log;
-  const removeSession = host.removeSession;
-  if (!removeSession)
-    throw new Error("Magic Context requires OpenCode 2.0.22 session.remove");
-  const lifecycle = createNativeHiddenChildren(host, (input) => removeSession.call(host, input), {
-    hook: options.hook,
-    generation,
-    keepSubagents: options.keepSubagents === true,
-    log: note,
-    removalTimeoutMs: options.removalTimeoutMs,
-    directory: options.directory
+function restoreRow(row, model, media) {
+  const data = row.data;
+  const make = (role, content, metadata = data.metadata) => ({
+    id: row.id,
+    role,
+    content,
+    ...metadata === undefined ? {} : { metadata }
   });
-  const acquireRole = async (role) => {
-    const previous = roleTails.get(role) ?? Promise.resolve();
-    let release;
-    const gate = new Promise((resolve) => {
-      release = resolve;
+  if (row.type === "user") {
+    const skills = data.skills ?? [];
+    const content = [
+      ...skills.flatMap((skill) => skill.text === undefined ? [] : [{ type: "text", text: skill.text }]),
+      ...data.text ? [{ type: "text", text: data.text }] : [],
+      ...attachmentParts(data.files ?? [], row.id, media)
+    ];
+    return content.length ? [
+      make("user", content, {
+        ...data.metadata ?? {},
+        ...data.agents?.length ? { agents: data.agents } : {}
+      })
+    ] : [];
+  }
+  if (row.type === "system")
+    return [{ role: "system", content: [{ type: "text", text: data.text ?? "" }] }];
+  if (row.type === "synthetic" && isStorageNoticeText(data.text))
+    return [];
+  if (["synthetic", "skill"].includes(row.type))
+    return [make("user", [{ type: "text", text: data.text ?? "" }])];
+  if (row.type === "location-switched")
+    return [
+      make("user", [
+        {
+          type: "text",
+          text: `The working directory has been changed to ${data.location.directory}.`
+        }
+      ])
+    ];
+  if (row.type === "shell")
+    return data.metadata?.background === true ? [] : [
+      make("user", [
+        {
+          type: "text",
+          text: `The following shell command was executed by the user:
+
+Command:
+${data.command}
+
+Output:
+${data.output?.output ?? ""}`
+        }
+      ])
+    ];
+  if (row.type !== "assistant")
+    return [];
+  const previousModel = data.model;
+  const sameProvider = previousModel?.providerID === model.providerID;
+  const sameModel = sameProvider && previousModel?.id === model.id;
+  const reuse = sameModel && data.error === undefined;
+  const metadata = (state) => state === undefined ? undefined : { [model.providerID]: state };
+  const content = [];
+  const results = [];
+  for (const part of data.content ?? []) {
+    if (part.type === "text") {
+      if (part.text !== "")
+        content.push({
+          type: "text",
+          text: part.text,
+          providerMetadata: reuse ? metadata(part.state) : undefined
+        });
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (part.text !== "" || reuse && part.state !== undefined)
+        content.push({
+          type: reuse || data.error === undefined ? "reasoning" : "text",
+          text: part.text,
+          providerMetadata: reuse ? metadata(part.state) : undefined
+        });
+      continue;
+    }
+    const state = part.state;
+    const completed = state.status === "completed" || state.status === "error";
+    const toolReuse = reuse || sameModel && part.executed === true && completed;
+    let input = state.input;
+    if (state.status === "streaming" && typeof input === "string") {
+      try {
+        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
     });
-    const tail = previous.then(() => gate);
-    roleTails.set(role, tail);
-    await previous;
-    return () => {
-      release();
-      if (roleTails.get(role) === tail)
-        roleTails.delete(role);
+    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" } : {}
     };
-  };
-  const warnedVariants = new Set;
-  const validateVariant = async (model) => {
-    if (!model.variant || !options.modelCatalog)
-      return model;
+    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 {
-      const listed = await options.modelCatalog();
-      const rows = Array.isArray(listed) ? listed : listed && typeof listed === "object" && Array.isArray(listed.data) ? listed.data : [];
-      const entry = rows.find((row) => row && typeof row === "object" && row.providerID === model.providerID && row.id === model.modelID);
-      if (!entry)
-        return model;
-      if (entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
-        return model;
-      const key = `${model.providerID}/${model.modelID}:${model.variant}`;
-      if (!warnedVariants.has(key)) {
-        warnedVariants.add(key);
-        note(`[magic-context] ${recordHiddenVariantWarning(model.providerID, model.modelID, model.variant)}`);
+      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();
       }
-      return { providerID: model.providerID, modelID: model.modelID };
     } catch {
-      return model;
-    }
-  };
-  const resolveHead = async (identity) => {
-    const configured = configuredHead(identity);
-    if (configured)
-      return validateVariant(configured);
-    if (!identity.parentSessionId) {
-      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion requires a configured model or an existing parent session model", true);
+      this.unavailable.add(draft.sessionID);
+      this.invalidate(draft.sessionID);
+    } finally {
+      this.account(draft.sessionID);
+      release();
     }
-    const parent = await host.get({ sessionID: identity.parentSessionId });
-    if (!parent.model) {
-      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion could not resolve the parent session model", true);
+  }
+  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();
     }
-    return {
-      providerID: parent.model.providerID,
-      modelID: parent.model.id,
-      ...parent.model.variant ? { variant: parent.model.variant } : {}
+  }
+  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
     };
-  };
-  const switchChildModel = async (run, requested) => {
-    if (sameModel(run.child.model, requested))
+    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;
-    await host.switchModel({
-      sessionID: run.child.id,
-      model: {
-        providerID: requested.providerID,
-        id: requested.modelID,
-        ...requested.variant ? { variant: requested.variant } : {}
+    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);
       }
-    });
-    run.child = lifecycle.updateModel(run.child, requested);
-  };
-  const retire = (run, reason) => {
-    if (run.retired)
-      return;
-    lifecycle.retire(run.child, reason);
-    run.retired = true;
-  };
-  const interruptAndRetire = async (run, reason) => {
+    } 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 {
-      await host.interrupt({ sessionID: run.child.id });
+      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 {
-      retire(run, reason);
+      reader.close();
     }
-  };
-  return {
-    capabilities: V2_HIDDEN_EXECUTOR_CAPABILITIES,
-    async open(identity) {
-      const role = roleFor(identity);
-      const releaseRole = await acquireRole(role);
-      let openedChild;
+  }
+  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 {
-        await options.ensureAgent?.();
-        const head = await resolveHead(identity);
-        const active = await lifecycle.open(identity, role, head);
-        openedChild = active;
-        const handle = { id: active.id, childSessionId: active.id };
-        const run = {
-          identity,
-          role,
-          child: active,
-          releaseRole,
-          failed: false,
-          unsettledFailure: false,
-          retired: false
-        };
-        runs.set(handle, run);
-        await switchChildModel(run, head);
-        return handle;
-      } catch (error) {
-        if (openedChild)
-          lifecycle.retire(openedChild, "hidden-run-open-failed");
-        releaseRole();
-        throw error;
-      }
-    },
-    async attempt(handle, request) {
-      const run = runs.get(handle);
-      if (!run)
-        throw new Error("Unknown hidden completion run");
-      if (request.signal?.aborted) {
-        await interruptAndRetire(run, "aborted-before-prompt");
-        throw new Error("Hidden completion prompt aborted");
-      }
-      const requested = await validateVariant(requestModel(request, run.child.model));
-      if (run.retired) {
-        run.child = await lifecycle.create(run.identity, run.role, requested);
-        run.failed = false;
-        run.unsettledFailure = false;
-        run.retired = false;
-        handle.id = run.child.id;
-        handle.childSessionId = run.child.id;
-      }
-      await switchChildModel(run, requested);
-      const baseline = withReader(options.openReader, (reader) => reader.latestSequence(run.child.id));
-      const marker = `mc:hidden:${crypto.randomUUID()}:${crypto.randomUUID()}`;
-      run.completion = undefined;
-      const stepCap = options.resolveStepCap?.(run.identity);
-      const attempt = {
-        childSessionId: run.child.id,
-        identity: run.identity,
-        agent: run.identity.agent,
-        request,
-        shaped: false,
-        ...stepCap === undefined ? {} : { stepCap }
-      };
-      options.hook.registerAttempt(marker, attempt);
-      const deadline = Date.now() + run.identity.timeoutMs;
-      let abortReject;
-      const aborted = new Promise((_resolve, reject) => {
-        abortReject = reject;
-      });
-      const onAbort = () => {
-        interruptAndRetire(run, "prompt-aborted").finally(() => abortReject(new Error("Hidden completion prompt aborted")));
-      };
-      const deadlineTimer = setTimeout(() => {
-        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");
+        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;
         }
-        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 }
+        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()
         };
-        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;
+        claimed = await storage.claim(sessionID, id, JSON.stringify(attempt), this.owner, now());
+        if (!claimed)
+          return;
       } finally {
-        clearTimeout(deadlineTimer);
-        request.signal?.removeEventListener("abort", onAbort);
-        options.hook.releaseAttempt(marker);
+        reader.close();
       }
-    },
-    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;
+      const admitted = await session.compact({
+        sessionID,
+        id: attempt.id,
+        delivery: "queue"
+      });
+      await session.wait({ sessionID });
+      const settled = this.deps.openReader();
       try {
-        const reusable = !run.retired && run.failed && !run.unsettledFailure;
-        if (!run.completion && (run.failed || !settlement.promptSettled) && !reusable) {
-          retire(run, "hidden-run-failed");
+        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 {
-        runs.delete(handle);
-        run.releaseRole();
+        settled.close();
       }
-      await lifecycle.finish(run.child, run.retired);
+    } 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);
     }
-  };
-}
-
-// 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);
+
+// src/v2/fork-inheritance.ts
+var RAW_TYPES = new Set(RAW_MESSAGE_TYPES);
+function forkBoundarySeq(origin, sequenceForId) {
+  const seq = sequenceForId(origin.parentSessionID, origin.boundary.messageID);
+  if (seq === undefined)
+    return;
+  return origin.boundary.type === "before" ? seq - 1 : seq;
 }
-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);
+function buildForkIdMap(parentRows, forkRows, throughSeq) {
+  const parentBySeq = new Map;
+  for (const row of parentRows)
+    if (row.seq <= throughSeq)
+      parentBySeq.set(row.seq, row);
+  const parentToFork = new Map;
+  const forkOrdinals = new Map;
+  let ordinal = 0;
+  for (const row of forkRows) {
+    if (row.seq > throughSeq)
+      break;
+    if (RAW_TYPES.has(row.type)) {
+      ordinal += 1;
+      forkOrdinals.set(row.id, ordinal);
+    }
+    const parent = parentBySeq.get(row.seq);
+    if (parent && parent.type === row.type && parent.time_created === row.time_created && row.id !== parent.id && row.id.endsWith(`_${row.seq}`)) {
+      parentToFork.set(parent.id, row.id);
+    }
   }
-  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;
+  const parentOrdinals = new Map;
+  let parentOrdinal = 0;
+  for (const row of parentRows) {
+    if (row.seq > throughSeq)
+      break;
+    if (!RAW_TYPES.has(row.type))
+      continue;
+    parentOrdinal += 1;
+    parentOrdinals.set(parentOrdinal, row.id);
   }
-  casChannel2NudgeClaim(db, sessionID, "delivered", token);
+  return { parentToFork, forkOrdinals, parentOrdinals, throughSeq };
 }
-
-// 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
-        });
+var CONTENT_ID_SUFFIX = /(:(?:p|file)\d+)$/;
+var BLOCK_ID_SUFFIX = /(#\d+)$/;
+function splitMessageScopedId(id) {
+  const match = id.match(CONTENT_ID_SUFFIX) ?? id.match(BLOCK_ID_SUFFIX);
+  if (!match?.[1])
+    return { messageId: id, suffix: "" };
+  return { messageId: id.slice(0, -match[1].length), suffix: match[1] };
+}
+function forkCloneFilter(idMap, copiedToolCallIds) {
+  const mapMessageScoped = (id) => {
+    const direct = idMap.parentToFork.get(id);
+    if (direct)
+      return direct;
+    const { messageId, suffix } = splitMessageScopedId(id);
+    if (!suffix)
+      return;
+    const mapped = idMap.parentToFork.get(messageId);
+    return mapped ? `${mapped}${suffix}` : undefined;
+  };
+  return {
+    resolveBoundaryOrdinal: (messageId) => {
+      const forkId = idMap.parentToFork.get(messageId);
+      return forkId ? idMap.forkOrdinals.get(forkId) : undefined;
+    },
+    includeMessageId: (messageId) => mapMessageScoped(messageId) !== undefined || copiedToolCallIds.has(messageId),
+    mapMessageId: (messageId) => mapMessageScoped(messageId) ?? messageId,
+    includeTag: (tag) => {
+      if (tag.type === "tool") {
+        return tag.toolOwnerMessageId !== null && idMap.parentToFork.has(tag.toolOwnerMessageId);
       }
-    });
-  } 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;
+      return mapMessageScoped(tag.messageId) !== undefined;
+    },
+    mapOrdinal: (sourceOrdinal) => {
+      const parentId = idMap.parentOrdinals.get(sourceOrdinal);
+      const forkId = parentId ? idMap.parentToFork.get(parentId) : undefined;
+      return forkId ? idMap.forkOrdinals.get(forkId) : undefined;
+    },
+    copySessionNotesAndFacts: true,
+    selectPendingPiMarker: () => null
+  };
 }
-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 countSessionRows(db, table, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE session_id = ?`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
 }
-function reportResult(sessionID, title, message) {
-  pushNotification2("action", { action: "show-result-dialog", title, message }, sessionID);
+function sessionHasMagicContextState(db, sessionId) {
+  return countSessionRows(db, "compartments", sessionId) > 0 || countSessionRows(db, "tags", sessionId) > 0;
 }
-function reportUsage(sessionID, message) {
-  pushNotification2("toast", { message, variant: "warning" }, sessionID);
+function seedV2ForkFromParent(args) {
+  const { db, store, sessionId } = args;
+  if (sessionHasMagicContextState(db, sessionId))
+    return { kind: "has-state" };
+  const origin = store.forkOrigin(sessionId);
+  if (!origin)
+    return { kind: "not-a-fork" };
+  const parentSessionID = origin.parentSessionID;
+  if (parentSessionID === sessionId)
+    return { kind: "not-a-fork" };
+  if (!sessionHasMagicContextState(db, parentSessionID))
+    return { kind: "parent-missing", parentSessionID, reason: "no Magic Context state" };
+  if (!store.sessionExists(parentSessionID))
+    return { kind: "parent-missing", parentSessionID, reason: "no host session row" };
+  const throughSeq = forkBoundarySeq(origin, (session, id) => store.sequenceForId(session, id));
+  if (throughSeq === undefined)
+    return { kind: "parent-missing", parentSessionID, reason: "boundary row not in the store" };
+  const idMap = buildForkIdMap(store.rowStampsThrough(parentSessionID, throughSeq), store.rowStampsThrough(sessionId, throughSeq), throughSeq);
+  if (idMap.parentToFork.size === 0)
+    return { kind: "parent-missing", parentSessionID, reason: "no copied rows pair up" };
+  const toolTags = db.prepare("SELECT message_id, tool_owner_message_id FROM tags WHERE session_id = ? AND type = 'tool'").all(parentSessionID);
+  const copiedToolCallIds = new Set(toolTags.filter((row) => row.tool_owner_message_id !== null && idMap.parentToFork.has(row.tool_owner_message_id)).map((row) => row.message_id));
+  const result = copySessionStateForClone(db, parentSessionID, sessionId, forkCloneFilter(idMap, copiedToolCallIds));
+  if (result.kind === "destination-not-empty")
+    return { kind: "destination-not-empty", parentSessionID };
+  return { kind: "seeded", parentSessionID, pairedRows: idMap.parentToFork.size, result };
 }
-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 : "");
+
+// src/v2/hidden-child-record.ts
+function keptUnderRetention(keepSubagents, child) {
+  return keepSubagents && (child.ever_settled === true || child.role === "historian");
 }
-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;
-        }
-        const reply = await rpc.dispatch("recomp", { sessionId: input.sessionID });
-        if (reply.ok !== true) {
-          throw new Error("Magic Context could not start the history rebuild.");
-        }
-      }
-    },
-    {
-      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);
-        }
-        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);
-        }
-        const reply = await rpc.dispatch("wrapup", {
-          sessionId: input.sessionID,
-          messagesToKeep
-        });
-        reportRpcReply(input.sessionID, "Wrapup", reply, "Wrapup started; the summary appears when it finishes");
-      }
+var HIDDEN_CHILD_ROLE_TITLES = {
+  "maintainer-a": "Magic Context maintainer A",
+  "maintainer-b": "Magic Context maintainer B",
+  historian: "Magic Context historian"
+};
+function roleTitle(role) {
+  return HIDDEN_CHILD_ROLE_TITLES[role];
+}
+function roleAgent(role) {
+  if (role === "maintainer-a")
+    return MEMORY_MAINTAINER_A_AGENT;
+  if (role === "maintainer-b")
+    return MEMORY_MAINTAINER_B_AGENT;
+  return HIDDEN_HISTORIAN_AGENT;
+}
+function childCreateInput(identity, role, model) {
+  const agent = roleAgent(role);
+  return {
+    title: roleTitle(role),
+    agent,
+    model: {
+      providerID: model.providerID,
+      id: model.modelID,
+      ...model.variant ? { variant: model.variant } : {}
     },
-    {
-      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);
-        }
-        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");
-      }
-    }
-  ];
+    location: { directory: identity.directory },
+    metadata: { magic_context: "hidden-run", role },
+    permissions: hiddenChildPermissions(agent)
+  };
 }
-
-// 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();
+function assistantOutcome(row) {
+  const outcome = row?.data.outcome;
+  return outcome === "succeeded" || outcome === "failed" || outcome === "interrupted" ? outcome : undefined;
+}
+function withReader(openReader, read) {
+  const reader = openReader();
+  try {
+    return read(reader);
+  } finally {
+    reader.close?.();
   }
-  get size() {
-    return this.#ids.size;
+}
+function errorText(value) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
 }
 
-// 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);
+// src/v2/hidden-child-native.ts
+function nativeSessionRemove(session) {
+  const remove = session.remove;
+  if (typeof remove !== "function")
+    return;
+  return (input) => Promise.resolve(remove.call(session, { sessionID: input.sessionID }));
 }
-function isHostInstance(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
+function isSessionNotFound(error) {
+  if (!error || typeof error !== "object")
     return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype !== Object.prototype && prototype !== null;
-}
-function containsHostInstance(value) {
-  if (isHostInstance(value))
+  const fields = error;
+  if (fields.status === 404)
     return true;
-  if (Array.isArray(value))
-    return value.some(containsHostInstance);
-  if (value && typeof value === "object")
-    return Object.values(value).some(containsHostInstance);
-  return false;
-}
-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;
+  const label = [fields.name, fields._tag, fields.message].filter((value) => typeof value === "string").join(" ");
+  return /not\s*found/i.test(label);
 }
-function contentKey(value) {
-  const plain = (entry) => {
-    if (ArrayBuffer.isView(entry)) {
-      return {
-        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
-      };
+var parentDroppedNoted = false;
+function createNativeHiddenChildren(host, removeSession, options) {
+  const removing = new Map;
+  const remove = (child) => {
+    const inFlight = removing.get(child.id);
+    if (inFlight)
+      return inFlight;
+    const done = (async () => {
+      try {
+        let timer;
+        try {
+          await Promise.race([
+            removeSession({ sessionID: child.id }),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error("session.remove timed out")), options.removalTimeoutMs ?? 5000);
+            })
+          ]);
+        } finally {
+          if (timer)
+            clearTimeout(timer);
+        }
+      } catch (error) {
+        if (isSessionNotFound(error))
+          return;
+        options.log(`[magic-context] hidden child ${child.id} could not be removed; it goes when its parent session is deleted: ${errorText(error)}`);
+      }
+    })().finally(() => {
+      removing.delete(child.id);
+    });
+    removing.set(child.id, done);
+    return done;
+  };
+  const confirmPlacement = async (sessionID, parentID) => {
+    let stored;
+    try {
+      stored = await host.get({ sessionID });
+    } catch (error) {
+      options.log(`[magic-context] could not read back hidden child ${sessionID} to confirm its parent: ${errorText(error)}`);
+      return;
     }
-    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)]));
+    const directory = stored.location?.directory;
+    if (options.directory !== undefined && directory !== undefined && directory !== options.directory) {
+      throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", `hidden child ${sessionID} is bound to ${directory}, not to this instance's ${options.directory}`, true);
     }
-    return entry;
+    if (stored.parentID === parentID || parentDroppedNoted)
+      return;
+    parentDroppedNoted = true;
+    options.log(`[magic-context] this OpenCode 2 host does not keep the parent of hidden-run sessions (asked for ${parentID}, read back ${stored.parentID ?? "none"}); they are created as separate sessions and still removed when each run ends`);
+  };
+  const create = async (identity, role, model) => {
+    const parentID = identity.parentSessionId;
+    const input = childCreateInput(identity, role, model);
+    const { location, ...parented } = input;
+    const created = await host.create(parentID ? { ...parented, parentID } : { ...parented, location });
+    if (!created.id)
+      throw new Error("OpenCode 2 did not return a child session id");
+    options.hook.registerChild(created.id, input.agent);
+    const child = {
+      id: created.id,
+      role,
+      generation: options.generation,
+      title: roleTitle(role),
+      model,
+      created_at: Date.now(),
+      directory: identity.directory
+    };
+    if (parentID) {
+      try {
+        await confirmPlacement(created.id, parentID);
+      } catch (error) {
+        await remove(child);
+        throw error;
+      }
+    }
+    return child;
+  };
+  const kept = (child) => keptUnderRetention(options.keepSubagents, child);
+  return {
+    open: create,
+    create,
+    retire(child) {
+      if (!kept(child))
+        remove(child);
+    },
+    async finish(child, retired) {
+      if (retired) {
+        await removing.get(child.id);
+        return;
+      }
+      if (!kept(child))
+        await remove(child);
+    },
+    updateModel: (child, model) => ({ ...child, model }),
+    markEverSettled: (child) => ({ ...child, ever_settled: true })
   };
-  return JSON.stringify(plain(value));
 }
-function fileContentValue(result) {
-  const value = result?.value;
-  if (result?.type !== "content" || !Array.isArray(value))
+
+// src/v2/hidden-child-cleanup.ts
+var PREFIX = "opencode2_hidden_children:";
+var COMPLETE = "opencode2_hidden_children_cleanup_complete";
+async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
+  if (db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key = ?").get(COMPLETE))
     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);
+  const rows = db.prepare("SELECT key, value FROM schema_migrations_meta WHERE key GLOB ? ORDER BY key LIMIT 25").all(`${PREFIX}*`);
+  let remaining = options.limit ?? 25;
+  const now = options.now ?? (() => performance.now());
+  const deadline = now() + (options.budgetMs ?? 2000);
+  for (const row of rows) {
+    let record;
+    try {
+      record = JSON.parse(row.value);
+      if (!record || typeof record !== "object" || record.active !== undefined && (!record.active || typeof record.active !== "object" || Array.isArray(record.active)) || record.retired_children !== undefined && !Array.isArray(record.retired_children))
+        throw new Error("invalid record");
+    } catch {
+      note(`[magic-context] legacy hidden-child cleanup cannot read ${row.key}`);
       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 children = [
+      ...Object.values(record.active ?? {}),
+      ...record.retired_children ?? []
+    ];
+    for (const child of children) {
+      if (remaining-- <= 0 || now() >= deadline)
+        return;
+      if (typeof child?.id !== "string") {
+        note(`[magic-context] legacy hidden-child cleanup has an invalid child in ${row.key}`);
+        continue;
+      }
+      let timer;
+      try {
+        try {
+          await Promise.race([
+            remove({ sessionID: child.id }),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error("session.remove timed out")), Math.min(options.timeoutMs ?? 1000, Math.max(1, deadline - now())));
+            })
+          ]);
+        } catch (error) {
+          if (!isSessionNotFound(error))
+            throw error;
+        }
+        record.active = Object.fromEntries(Object.entries(record.active ?? {}).filter(([, entry]) => entry.id !== child.id));
+        record.retired_children = (record.retired_children ?? []).filter((entry) => entry.id !== child.id);
+        db.prepare("UPDATE schema_migrations_meta SET value = ? WHERE key = ?").run(JSON.stringify(record), row.key);
+      } catch (error) {
+        note(`[magic-context] legacy hidden child ${child.id} cleanup deferred: ${String(error)}`);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
       }
     }
+    if (Object.keys(record.active ?? {}).length === 0 && (record.retired_children ?? []).length === 0)
+      db.prepare("DELETE FROM schema_migrations_meta WHERE key = ?").run(row.key);
   }
-  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;
+  if (!db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key GLOB ? LIMIT 1").get(`${PREFIX}*`))
+    db.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, 'true')").run(COMPLETE);
+}
+
+// src/v2/hidden-completion.ts
+var POLL_INTERVAL_MS = 200;
+function modelKey(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function sameModel(left, right) {
+  return modelKey(left) === modelKey(right) && left.variant === right.variant;
+}
+function configuredHead(identity) {
+  const candidates = [identity.model, ...identity.configuredModels ?? []];
+  for (const candidate of candidates) {
+    const entry = toModelEntry(candidate);
+    const parsed = entry ? parseProviderModel(entry.model) : null;
+    if (parsed)
+      return { ...parsed, ...entry?.qualifier ? { variant: entry.qualifier } : {} };
+  }
+  return;
+}
+var HIDDEN_MAINTAINER_ROLES = {
+  "maintainer-a": "magic-context-maintainer-a",
+  "maintainer-b": "magic-context-maintainer-b"
+};
+function roleFor(identity) {
+  for (const [role, agent] of Object.entries(HIDDEN_MAINTAINER_ROLES)) {
+    if (identity.agent === agent)
+      return role;
+  }
+  return "historian";
+}
+function promptText(request) {
+  const parts = request.body.parts;
+  return Array.isArray(parts) ? parts.flatMap((part) => part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []).join(`
+`) : "";
+}
+function meter(system, prompt, text) {
+  return {
+    input: estimateTokens(system) + estimateTokens(prompt),
+    output: estimateTokens(text),
+    cacheRead: 0,
+    cacheWrite: 0
   };
-  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 }
+}
+function assistantReasoning(row) {
+  const reasoning = (row.data.content ?? []).flatMap((part) => part.type === "reasoning" && typeof part.text === "string" ? [part.text] : []).join(`
+`);
+  return reasoning.length > 0 ? reasoning : null;
+}
+function assistantText(row) {
+  const text = (row.data.content ?? []).flatMap((part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("");
+  return text.length > 0 ? text : null;
+}
+
+class HiddenProviderError extends Error {
+  settled;
+  constructor(detail, options = {}) {
+    super(`Hidden completion provider error: ${detail}`);
+    this.name = "HiddenProviderError";
+    this.settled = options.settled ?? true;
+  }
+}
+function requestModel(request, current) {
+  const requested = request.body.model;
+  if (requested && typeof requested.providerID === "string" && typeof requested.modelID === "string") {
+    return {
+      providerID: requested.providerID,
+      modelID: requested.modelID,
+      ...typeof request.body.variant === "string" ? { variant: request.body.variant } : {}
     };
-    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);
+  return current;
+}
+async function sleepUntilPoll(signal, deadline) {
+  if (signal?.aborted)
+    throw new Error("Hidden completion prompt aborted");
+  const delay = Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now()));
+  if (delay <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delay);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(new Error("Hidden completion prompt aborted"));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted)
+      abort();
+    else
+      setTimeout(() => {
+        signal?.removeEventListener("abort", abort);
+      }, delay);
+  });
+}
+function isProviderFailure(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const type = error.type;
+  return typeof type === "string" && (type.startsWith("provider.") || type.toLowerCase().includes("provider"));
+}
+async function awaitAssistantRow(openReader, readSessionError, localFailure, childID, afterSeq, deadline, signal) {
+  for (;; ) {
+    const { assistant, idle } = withReader(openReader, (reader) => ({
+      assistant: reader.latestAssistant(childID),
+      idle: reader.latestIdle(childID)
+    }));
+    const newAssistant = assistant && assistant.seq > afterSeq ? assistant : undefined;
+    const newIdle = idle && idle.seq > afterSeq ? idle : undefined;
+    const refused = localFailure();
+    if (refused)
+      throw refused;
+    if (newIdle && (!newAssistant || newIdle.seq > newAssistant.seq)) {
+      const outcome = newIdle.data.outcome;
+      if (outcome === "failed" || outcome === "interrupted") {
+        const sessionError = await readSessionError();
+        const details = [
+          `outcome=${outcome}`,
+          `terminal_row=${errorText(newIdle)}`,
+          `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
+        ];
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+      }
+      if (outcome === "succeeded" && newAssistant)
+        return newAssistant;
     }
-    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 (newAssistant) {
+      const outcome = assistantOutcome(newAssistant);
+      if (outcome === "failed" || outcome === "interrupted") {
+        const sessionError = await readSessionError();
+        const details = [
+          `outcome=${outcome}`,
+          `terminal_row=${errorText(newAssistant)}`,
+          `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
+        ];
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+      }
+      if (newAssistant.data.error !== undefined) {
+        throw new HiddenProviderError(errorText(newAssistant.data.error), {
+          settled: typeof newAssistant.data.finish === "string"
+        });
+      }
+      if (typeof newAssistant.data.finish === "string" || outcome === "succeeded") {
+        return newAssistant;
+      }
     }
-    if (typeof message.id === "string") {
-      bridgesByMessageID.set(message.id, byCallID);
-      originalsByID.set(message.id, message);
+    if (Date.now() >= deadline) {
+      throw new Error("Hidden completion timed out waiting for a persisted assistant row");
     }
-    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);
+    await sleepUntilPoll(signal, deadline);
   }
+}
+var V2_HIDDEN_EXECUTOR_CAPABILITIES = {
+  tools: true,
+  harness: "opencode2"
+};
+function createLateHiddenExecutor(current) {
+  const wired = () => {
+    const executor = current();
+    if (executor)
+      return executor;
+    throw new Error("Magic Context hidden work is unavailable until the context database opens.");
+  };
   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
-                    }
-                  }
-                ]
+    get capabilities() {
+      return current()?.capabilities ?? V2_HIDDEN_EXECUTOR_CAPABILITIES;
+    },
+    open: (run) => wired().open(run),
+    attempt: (handle, request) => wired().attempt(handle, request),
+    collect: (handle, limit) => wired().collect(handle, limit),
+    close: (handle, settlement) => wired().close(handle, settlement)
+  };
+}
+async function createV2HiddenCompletionExecutor(host, options) {
+  const runs = new WeakMap;
+  const generation = options.generation ?? "opencode2";
+  const roleTails = new Map;
+  const note = options.log ?? log;
+  const removeSession = host.removeSession;
+  if (!removeSession)
+    throw new Error("Magic Context requires OpenCode 2.0.22 session.remove");
+  const lifecycle = createNativeHiddenChildren(host, (input) => removeSession.call(host, input), {
+    hook: options.hook,
+    generation,
+    keepSubagents: options.keepSubagents === true,
+    log: note,
+    removalTimeoutMs: options.removalTimeoutMs,
+    directory: options.directory
+  });
+  const acquireRole = async (role) => {
+    const previous = roleTails.get(role) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = previous.then(() => gate);
+    roleTails.set(role, tail);
+    await previous;
+    return () => {
+      release();
+      if (roleTails.get(role) === tail)
+        roleTails.delete(role);
+    };
+  };
+  const warnedVariants = new Set;
+  const validateVariant = async (model) => {
+    if (!model.variant || !options.modelCatalog)
+      return model;
+    try {
+      const listed = await options.modelCatalog();
+      const rows = Array.isArray(listed) ? listed : listed && typeof listed === "object" && Array.isArray(listed.data) ? listed.data : [];
+      const entry = rows.find((row) => row && typeof row === "object" && row.providerID === model.providerID && row.id === model.modelID);
+      if (!entry)
+        return model;
+      if (entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
+        return model;
+      const key = `${model.providerID}/${model.modelID}:${model.variant}`;
+      if (!warnedVariants.has(key)) {
+        warnedVariants.add(key);
+        note(`[magic-context] ${recordHiddenVariantWarning(model.providerID, model.modelID, model.variant)}`);
+      }
+      return { providerID: model.providerID, modelID: model.modelID };
+    } catch {
+      return model;
+    }
+  };
+  const resolveHead = async (identity) => {
+    const configured = configuredHead(identity);
+    if (configured)
+      return validateVariant(configured);
+    if (!identity.parentSessionId) {
+      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion requires a configured model or an existing parent session model", true);
+    }
+    const parent = await host.get({ sessionID: identity.parentSessionId });
+    if (!parent.model) {
+      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion could not resolve the parent session model", true);
+    }
+    return {
+      providerID: parent.model.providerID,
+      modelID: parent.model.id,
+      ...parent.model.variant ? { variant: parent.model.variant } : {}
+    };
+  };
+  const switchChildModel = async (run, requested) => {
+    if (sameModel(run.child.model, requested))
+      return;
+    await host.switchModel({
+      sessionID: run.child.id,
+      model: {
+        providerID: requested.providerID,
+        id: requested.modelID,
+        ...requested.variant ? { variant: requested.variant } : {}
+      }
+    });
+    run.child = lifecycle.updateModel(run.child, requested);
+  };
+  const retire = (run, reason) => {
+    if (run.retired)
+      return;
+    lifecycle.retire(run.child, reason);
+    run.retired = true;
+  };
+  const interruptAndRetire = async (run, reason) => {
+    try {
+      await host.interrupt({ sessionID: run.child.id });
+    } finally {
+      retire(run, reason);
+    }
+  };
+  return {
+    capabilities: V2_HIDDEN_EXECUTOR_CAPABILITIES,
+    async open(identity) {
+      const role = roleFor(identity);
+      const releaseRole = await acquireRole(role);
+      let openedChild;
+      try {
+        await options.ensureAgent?.();
+        const head = await resolveHead(identity);
+        const active = await lifecycle.open(identity, role, head);
+        openedChild = active;
+        const handle = { id: active.id, childSessionId: active.id };
+        const run = {
+          identity,
+          role,
+          child: active,
+          releaseRole,
+          failed: false,
+          unsettledFailure: false,
+          retired: false
+        };
+        runs.set(handle, run);
+        await switchChildModel(run, head);
+        return handle;
+      } catch (error) {
+        if (openedChild)
+          lifecycle.retire(openedChild, "hidden-run-open-failed");
+        releaseRole();
+        throw error;
+      }
+    },
+    async attempt(handle, request) {
+      const run = runs.get(handle);
+      if (!run)
+        throw new Error("Unknown hidden completion run");
+      if (request.signal?.aborted) {
+        await interruptAndRetire(run, "aborted-before-prompt");
+        throw new Error("Hidden completion prompt aborted");
+      }
+      const requested = await validateVariant(requestModel(request, run.child.model));
+      if (run.retired) {
+        run.child = await lifecycle.create(run.identity, run.role, requested);
+        run.failed = false;
+        run.unsettledFailure = false;
+        run.retired = false;
+        handle.id = run.child.id;
+        handle.childSessionId = run.child.id;
+      }
+      await switchChildModel(run, requested);
+      const baseline = withReader(options.openReader, (reader) => reader.latestSequence(run.child.id));
+      const marker = `mc:hidden:${crypto.randomUUID()}:${crypto.randomUUID()}`;
+      run.completion = undefined;
+      const stepCap = options.resolveStepCap?.(run.identity);
+      const attempt = {
+        childSessionId: run.child.id,
+        identity: run.identity,
+        agent: run.identity.agent,
+        request,
+        shaped: false,
+        ...stepCap === undefined ? {} : { stepCap }
+      };
+      options.hook.registerAttempt(marker, attempt);
+      const deadline = Date.now() + run.identity.timeoutMs;
+      let abortReject;
+      const aborted = new Promise((_resolve, reject) => {
+        abortReject = reject;
+      });
+      const onAbort = () => {
+        interruptAndRetire(run, "prompt-aborted").finally(() => abortReject(new Error("Hidden completion prompt aborted")));
+      };
+      const deadlineTimer = setTimeout(() => {
+        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;
             }
-            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] });
-          }
+          }, () => 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 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}`);
         }
-        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);
+        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;
+        }
+        const reply = await rpc.dispatch("recomp", { sessionId: input.sessionID });
+        if (reply.ok !== true) {
+          throw new Error("Magic Context could not start the history rebuild.");
         }
-        rendered.push(...following);
       }
-      draft.messages.splice(0, draft.messages.length, ...rendered);
+    },
+    {
+      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);
+        }
+        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);
+        }
+        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);
+        }
+        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");
+      }
     }
-  };
+  ];
+}
+
+// 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 +21272,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 +21289,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 +21481,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 +21623,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",
@@ -21304,7 +22143,7 @@ Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversiz
 
 Finer recovery:
 - verbose=true lists each message separately with its ordinal and a per-part preview (tool calls with output sizes) so you can pick one.
-- message=N returns that one message in full — every text part and every tool call's complete input and output — from stored history. This is the way back to a tool output you released with mmc_reduce; if the message was deleted from history it says so.`;
+- message=N returns that one message in full — every text part and every tool call's complete input and output — from stored history. This is the way back to a tool output you released with mmc_reduce; if the message is no longer in stored history it says so.`;
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
 // src/features/magic-context/tag-input.ts
@@ -21377,7 +22216,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 +22305,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);
@@ -21530,7 +22369,7 @@ function renderMessageByOrdinal(sessionId, ordinal) {
   });
   const msg = found[0];
   if (!msg) {
-    return `No message at ordinal ${ordinal} in this session's stored history — it was deleted ` + `(session prune/revert) or the ordinal is wrong, so it can't be recovered. ` + `Re-run the tool if you still need the data.`;
+    return `No message at ordinal ${ordinal} is currently in this session's stored history — ` + `it may have been removed by a session prune/revert, or the ordinal may be wrong. ` + `Re-run the tool if you still need the data.`;
   }
   const rendered = msg.parts.map(renderPartFull).filter((l) => l !== null);
   const lines = [`[${msg.ordinal}] ${roleLabel(msg.role)} — full recovery:`, ""];
@@ -21601,9 +22440,12 @@ 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.`;
+  if (!selected)
+    return `Tag ${number}'s original text part is no longer in stored history.`;
+  const renderedPart = renderPartFull(selected);
+  return renderedPart !== null ? renderedPart : `Tag ${number}'s stored text part has no renderable content (empty or structural-only); the requested content was not recovered.`;
 }
 
 // src/tools/ctx-expand/tools.ts
@@ -21629,52 +22471,57 @@ function createCtxExpandTool(deps) {
         message: "number"
       });
       const sessionId = toolContext.sessionID;
-      const mode = resolveCtxExpandMode(args, "positive");
-      if (mode.kind === "error") {
-        return mode.message;
-      }
-      if (mode.kind === "tag") {
-        return renderItemByTag(deps.db, sessionId, mode.tag);
-      }
-      if (mode.kind === "message") {
-        return renderMessageByOrdinal(sessionId, mode.message);
-      }
-      const { start, end, verbose } = mode;
-      const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
-      if (lastCompartmentEnd >= 0 && start > lastCompartmentEnd) {
-        return `Range ${start}-${end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
-      }
-      const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(end, lastCompartmentEnd) : end;
-      if (verbose) {
-        const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET, deps.expandTools);
-        if (!v.text) {
-          return `No messages found in range ${start}-${effectiveEnd}. The range may be outside this session's history.`;
+      try {
+        const mode = resolveCtxExpandMode(args, "positive");
+        if (mode.kind === "error") {
+          return mode.message;
         }
-        const out = [
-          `Messages ${start}-${v.lastOrdinal} (verbose). Recover any one in full with mmc_expand(message=<ordinal>):`,
-          "",
-          v.text
-        ];
-        if (v.truncated) {
-          out.push("", `Truncated at message ${v.lastOrdinal} (budget: ~${CTX_EXPAND_TOKEN_BUDGET} tokens). Call again with start=${v.lastOrdinal + 1} end=${effectiveEnd} verbose=true for more.`);
+        if (mode.kind === "tag") {
+          return renderItemByTag(deps.db, sessionId, mode.tag);
         }
-        return out.join(`
+        if (mode.kind === "message") {
+          return renderMessageByOrdinal(sessionId, mode.message);
+        }
+        const { start, end, verbose } = mode;
+        const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
+        if (lastCompartmentEnd >= 0 && start > lastCompartmentEnd) {
+          return `Range ${start}-${end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
+        }
+        const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(end, lastCompartmentEnd) : end;
+        if (verbose) {
+          const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET, deps.expandTools);
+          if (!v.text) {
+            return `No messages found in range ${start}-${effectiveEnd}. The range may be outside this session's history.`;
+          }
+          const out = [
+            `Messages ${start}-${v.lastOrdinal} (verbose). Recover any one in full with mmc_expand(message=<ordinal>):`,
+            "",
+            v.text
+          ];
+          if (v.truncated) {
+            out.push("", `Truncated at message ${v.lastOrdinal} (budget: ~${CTX_EXPAND_TOKEN_BUDGET} tokens). Call again with start=${v.lastOrdinal + 1} end=${effectiveEnd} verbose=true for more.`);
+          }
+          return out.join(`
 `);
-      }
-      const chunk = readSessionChunk2(sessionId, CTX_EXPAND_TOKEN_BUDGET, start, effectiveEnd + 1, { expand: false });
-      if (!chunk.text || chunk.messageCount === 0) {
-        return `No messages found in range ${start}-${end}. The range may be outside this session's history.`;
-      }
-      const lines = [];
-      lines.push(`Messages ${chunk.startIndex}-${chunk.endIndex} (${chunk.messageCount} messages, ~${chunk.tokenEstimate} tokens):`);
-      lines.push("");
-      lines.push(chunk.text);
-      if (chunk.endIndex < effectiveEnd) {
+        }
+        const chunk = readSessionChunk2(sessionId, CTX_EXPAND_TOKEN_BUDGET, start, effectiveEnd + 1, { expand: false });
+        if (!chunk.text || chunk.messageCount === 0) {
+          return `No messages found in range ${start}-${end}. The range may be outside this session's history.`;
+        }
+        const lines = [];
+        lines.push(`Messages ${chunk.startIndex}-${chunk.endIndex} (${chunk.messageCount} messages, ~${chunk.tokenEstimate} tokens):`);
         lines.push("");
-        lines.push(`Truncated at message ${chunk.endIndex} (budget: ~${CTX_EXPAND_TOKEN_BUDGET} tokens). Call again with start=${chunk.endIndex + 1} end=${effectiveEnd} for more.`);
-      }
-      return lines.join(`
+        lines.push(chunk.text);
+        if (chunk.endIndex < effectiveEnd) {
+          lines.push("");
+          lines.push(`Truncated at message ${chunk.endIndex} (budget: ~${CTX_EXPAND_TOKEN_BUDGET} tokens). Call again with start=${chunk.endIndex + 1} end=${effectiveEnd} for more.`);
+        }
+        return lines.join(`
 `);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error: mmc_expand failed to read this session's stored history: ${message}`;
+      }
     }
   });
 }
@@ -22912,6 +23759,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 +23970,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 +24003,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 +24270,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 +24288,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 +24317,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 +24330,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 +24372,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 +24444,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 +24680,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 +24728,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 +24761,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 +24776,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 +24805,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;