@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/dist/{context-sh2m2vde.js → context-m0cy262m.js}

@@ -11,10 +11,7 @@ import {
   withLiveDreamerOutputCap,
   renderUserFacingFailure,
   userFacingFailureCode,
-  advanceSessionActivity,
-  backfillSessionActivity,
   invalidateAutoEmbedSession,
-  deleteChunkEmbedBackoffForSession,
   acquireCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
@@ -60,6 +57,7 @@ import {
   HiddenChildHook,
   parseProviderModel,
   toModelEntry,
+  CTX_NOTE_LIGHT_DESCRIPTION,
   ACTIVE_TOOL_IDS,
   createPromptSurfaceRuntime,
   runTokenLog,
@@ -69,17 +67,19 @@ import {
   resetPrefixTrimFallbackState,
   resolveOpenCodeProtectedTailBoundary,
   getActiveCompartmentRun
-} from "./index-sjthx78w.js";
+} from "./index-692jzy0p.js";
 import"./index-sd3egckz.js";
 import {
-  getHarness,
+  getHarness2
+} from "./index-pavzsdc6.js";
+import {
   getDataDir,
   getMagicContextStorageDir
-} from "./index-q6hef7fh.js";
+} from "./index-0sahzkwr.js";
 import {
-  log,
-  sessionLog
-} from "./index-hybnrwq0.js";
+  log2,
+  sessionLog2
+} from "./index-8j7gqj40.js";
 import {
   isSaneLimit,
   setOutputReserveConfig,
@@ -89,9 +89,9 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-0d3g3461.js";
-import"./index-8x2v7gg9.js";
-import"./index-q4yp4b52.js";
+} from "./index-pdecwzrd.js";
+import"./index-bhvjj0ys.js";
+import"./index-mfkzp7qj.js";
 import {
   CANONICAL_DREAM_TASKS,
   DREAM_TASK_CAPABILITIES,
@@ -99,66 +99,86 @@ import {
   isCanonicalDreamTask,
   buildDreamTaskRuntimeConfigs2,
   userMemoryCollectionEnabled2
-} from "./index-mc22ayvf.js";
+} from "./index-ghc9f0n7.js";
 import {
   resolveHistorianModel2
-} from "./index-sfpzqvdz.js";
+} from "./index-8cd2j99z.js";
 import {
   formatFailClosedBlockingMessage,
   formatFailClosedBlockingSummary,
   createFailClosedBlockingError,
   isFailClosedBlockingError,
-  setHomeProjectPermission,
-  resolveProjectIdentityForSession,
-  scheduleAfterBootQuiet,
   startBootDeadline,
   BOOT_SQLITE_BUSY_TIMEOUT_MS,
   openCurrentDatabase,
   openDatabaseAsync,
   isDatabasePersisted,
   getDatabasePersistenceError
-} from "./index-r5hmbx3t.js";
+} from "./index-q7h7csab.js";
+import {
+  setHomeProjectPermission,
+  resolveProjectIdentityForSession,
+  scheduleAfterBootQuiet
+} from "./index-knh4y330.js";
 import {
-  isDroppedToolOutput,
-  evaluateChannel2,
-  reclaimableToolOutputCount,
-  buildChannel2Reminder,
   markHostUnservedRow,
   DreamTokenBudgetExceeded,
   createDreamTokenBudget,
   recordToolParameters,
   createDroppedInputGuard,
   assertExecutableToolInput,
+  estimateFinalWireInputTokens,
   detectOverflow,
+  modelAcceptsEmptyContent,
   hasRawMessageProvider2,
   setBoundedRawMessageProvider2,
   cleanUserText2,
   readRawSessionMessageIdOrdinalsForRange2,
   readRawSessionMessageOrdinalById2
-} from "./index-3h0ybwah.js";
+} from "./index-bdckkfw6.js";
 import {
   hasMeaningfulUserText2,
   preloadTokenizer,
   estimateTokens
-} from "./index-5eqk6z3s.js";
+} from "./index-1qb0z7wa.js";
+import"./index-72nhv486.js";
+import {
+  withSqliteTransformPass2,
+  withoutSqliteTransformPass2,
+  isTransientSqliteError2,
+  withAsyncPrivilegedWriter2
+} from "./index-kb9nn0a0.js";
+import"./index-fbv1dn35.js";
+import {
+  deleteChunkEmbedBackoffForSession
+} from "./index-pg50n748.js";
 import {
-  withSqliteTransformPass,
-  withoutSqliteTransformPass,
-  isTransientSqliteError,
-  withAsyncPrivilegedWriter
-} from "./index-fg34g6a5.js";
+  advanceSessionActivity,
+  backfillSessionActivity
+} from "./index-14cjxt20.js";
+import"./index-db7zwa3v.js";
+import"./index-1zx87sdm.js";
+import {
+  isDroppedToolOutput,
+  evaluateChannel2,
+  reclaimableToolOutputCount,
+  buildChannel2Reminder
+} from "./index-k9nnwad5.js";
+import"./index-dhwzyd54.js";
+import"./index-58e3y90n.js";
+import"./index-ty64eqcn.js";
 import {
   getCurrentToolSetHash,
   recordToolDefinition
-} from "./index-5gq3b2ya.js";
-import"./index-1zx87sdm.js";
-import"./index-b35pxds2.js";
-import"./index-majxda46.js";
+} from "./index-0qhce371.js";
+import"./index-fr0wbhdn.js";
+import"./index-7mx8v0pw.js";
+import"./index-fb3zxn06.js";
+import"./index-c43kr12f.js";
+import"./index-cb7emxgj.js";
 import {
-  createSubcCheckoutClaimGate,
   runSessionProjectBackfill,
   createLiveSessionState,
-  getDefaultSubcConnectionFile,
   RETROSPECTIVE_MAX_USER_MESSAGE_CHARS,
   RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER,
   createDreamTaskExecutor,
@@ -176,6 +196,9 @@ import {
   createToolExecuteAfterHook,
   recordHiddenVariantWarning,
   registerRpcHandlers,
+  armLatestThinkingRecoveryFromError,
+  lkgReplayLimit,
+  measureLkgReplay,
   STORAGE_BUSY_MESSAGE,
   StorageBusyRefusalError,
   UnmanagedOverWindowError,
@@ -185,42 +208,50 @@ import {
   createModuleToolBackends,
   createRustRefusalRecovery,
   createSystemPromptHashHandler,
+  tryMessagesTransformLkgReplay,
   createMessagesTransformHandler,
   subagentToolRefusal,
   hideSubagentTools,
   createCtxExpandTools,
   createCtxMemoryTools,
   createCtxMemoryListTools,
+  CTX_NOTE_DESCRIPTION,
+  withoutSmartNoteText,
   createCtxNoteTools,
   createCtxReduceTools,
   createCtxSearchTools,
   applyJsonSchemaParameterDescriptions,
   MagicContextRpcServer
-} from "./index-hpecdzec.js";
+} from "./index-0an7742d.js";
 import {
   createTagger,
   setCtxReduceRegisteredGlobally,
   resolveCtxReduceAvailabilityFromMessages,
-  DegradedPassRefusalError,
   EmergencyFailClosedError,
+  DegradedPassRefusalError,
   isSyntheticHeadMessage2
-} from "./index-pkbcrdqs.js";
-import"./index-7qw742ev.js";
+} from "./index-f0h6xwqm.js";
+import"./index-qt1qqasc.js";
+import"./index-4dhv7mqz.js";
+import"./index-5zygecde.js";
+import"./index-7jzrrxap.js";
 import {
   pushNotification2,
   isTuiConnected2
 } from "./index-x8a7jmkh.js";
-import"./index-fzbvakh0.js";
-import"./index-sgthv3f7.js";
-import"./index-k5bdx1bx.js";
+import"./index-jcbd3znx.js";
+import"./index-yq8n9qcb.js";
+import"./index-mmyh6d8f.js";
+import"./index-0w56v4fm.js";
 import {
   detectConflicts
-} from "./index-8da2zjhz.js";
+} from "./index-eeezr5zz.js";
+import"./index-q2tqeqde.js";
 import"./index-fmsr7v69.js";
 import {
   getErrorMessage
 } from "./index-y8v6yerm.js";
-import"./index-sj29b3z2.js";
+import"./index-2y0s2hep.js";
 
 // src/hooks/magic-context/history-boundary-repair.ts
 function readBaseline(db, sessionId) {
@@ -296,7 +327,7 @@ function repairMissingHistoryBoundary(args) {
     if (anchor === "unknown")
       return { kind: "unknown" };
     if (anchor === null) {
-      sessionLog(sessionId, `history boundary unresolved: ${problem} and no older compartment end is in the host store; nothing to re-anchor on`);
+      sessionLog2(sessionId, `history boundary unresolved: ${problem} and no older compartment end is in the host store; nothing to re-anchor on`);
       return { kind: "unresolved", reason: "no-anchor", missingEndMessageId: missing };
     }
     if (getActiveCompartmentRun(sessionId) !== undefined) {
@@ -318,7 +349,7 @@ function repairMissingHistoryBoundary(args) {
     invalidateAutoEmbedSession(sessionId);
     forgetCachedPrefix(sessionId);
     const range = dropped.length === 0 ? "none" : `${dropped[0]}-${dropped[dropped.length - 1]} (${dropped.length})`;
-    sessionLog(sessionId, `history boundary repair: ${problem}; re-anchored on compartment ${anchor.sequence} ending at ${anchor.endMessageId} (ordinal ${anchor.endMessage}); removed compartments ${range} for the historian to rebuild; the cached prefix is rebuilt on this pass`);
+    sessionLog2(sessionId, `history boundary repair: ${problem}; re-anchored on compartment ${anchor.sequence} ending at ${anchor.endMessageId} (ordinal ${anchor.endMessage}); removed compartments ${range} for the historian to rebuild; the cached prefix is rebuilt on this pass`);
     return {
       kind: "repaired",
       missingEndMessageId: missing,
@@ -334,7 +365,7 @@ function repairMissingHistoryBoundary(args) {
     return { kind: "intact" };
   clearCachedM0M1(db, sessionId);
   forgetCachedPrefix(sessionId);
-  sessionLog(sessionId, `history boundary repair: the cached prefix boundary ${baseline.boundary} is not in the host store; rebuilding it on this pass against compartment end ${latestEnd}`);
+  sessionLog2(sessionId, `history boundary repair: the cached prefix boundary ${baseline.boundary} is not in the host store; rebuilding it on this pass against compartment end ${latestEnd}`);
   return {
     kind: "baseline-reset",
     anchorEndMessageId: latestEnd,
@@ -407,7 +438,7 @@ function createV2RustCompactionMarkerStrategy(findBoundaryUserMessage) {
         targetEndMessageId: pending.endMessageId
       };
       setPersistedCompactionMarkerState(db, sessionId, state);
-      sessionLog(sessionId, `v2 boundary recorded at ordinal ${pending.ordinal}, boundary message ${boundary.id}`);
+      sessionLog2(sessionId, `v2 boundary recorded at ordinal ${pending.ordinal}, boundary message ${boundary.id}`);
       return { kind: "applied", markerOrdinal: pending.ordinal };
     }
   };
@@ -539,7 +570,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";
@@ -559,7 +591,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)
@@ -567,18 +599,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 (!isRecord(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;
@@ -588,6 +632,9 @@ function hostMediaAsset(data, mediaType) {
   return `${first}; ${second}`;
 }
 
+// src/v2/fold/memory-cache.ts
+import { randomUUID } from "node:crypto";
+
 // src/v2/fold/owner.ts
 import { createHash } from "node:crypto";
 var foldDigest = (value) => createHash("sha256").update(value).digest("hex");
@@ -670,122 +717,777 @@ class FoldOwner {
   }
 }
 
-// src/v2/fold/restore.ts
-import { fileURLToPath } 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;
 
-// 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)}`;
+class NativeFoldCache {
+  resolveDB;
+  sourceID = randomUUID();
+  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 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 nativeFoldCache(db, budget) {
+  return new NativeFoldCache(typeof db === "function" ? db : () => db, budget);
 }
-function isStorageNoticeText(text) {
-  return typeof text === "string" && text.startsWith(STORAGE_NOTICE_PREFIX);
+
+// 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 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 toolErrorText(result) {
+  const value = result.value === undefined ? result : result.value;
+  return typeof value === "string" ? value : JSON.stringify(value);
 }
-async function dropStorageNotices(messages, isAdmittedSynthetic) {
-  const drop = new Set;
-  for (const message of messages) {
-    if (!hasStorageNoticeShape(message))
+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")
+    sessionLog2(message.info.sessionID, text);
+  else
+    log2(text);
+}
+var emptyTextOmissionLogged = new Set;
+function placeCacheHint(content, hint) {
+  if (content.length === 0 || content.some((part) => part.cache !== undefined))
+    return;
+  let lastText = content.length - 1;
+  while (lastText >= 0 && content[lastText]?.type !== "text")
+    lastText -= 1;
+  const index = lastText >= 0 ? lastText : content.length - 1;
+  content[index] = { ...content[index], cache: hint };
+}
+function removeEmptyTextParts(content, rendered) {
+  let hint;
+  let removed = 0;
+  for (let index = content.length - 1;index >= 0; index -= 1) {
+    const part = content[index];
+    if (part?.type !== "text" || part.text !== "")
       continue;
-    if (await isAdmittedSynthetic(message.id))
-      drop.add(message);
+    if (hint === undefined)
+      hint = part.cache;
+    content.splice(index, 1);
+    removed += 1;
   }
-  if (drop.size === 0)
-    return 0;
-  const kept = messages.filter((message) => !drop.has(message));
-  messages.splice(0, messages.length, ...kept);
-  return drop.size;
+  if (hint !== undefined) {
+    const target = content.length > 0 ? content : rendered.at(-1)?.content;
+    if (target)
+      placeCacheHint(target, hint);
+  }
+  return removed;
 }
-
-// src/v2/fold/restore.ts
-function unavailableAttachmentNote(name, mediaType) {
-  return `[Attachment ${name ? `"${name}" ` : ""}(${mediaType}) is not available in this restored history]`;
+function isHostInstance(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype !== Object.prototype && prototype !== null;
 }
-var imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-function attachmentParts(files, rowID, media) {
-  const seen = new Map;
-  return files.flatMap((file) => {
-    if (imageMimes.has(file.mime) && file.source.type === "inline" && file.mention?.text) {
-      const key = JSON.stringify([
-        file.mime,
-        file.name ?? null,
-        file.description ?? null,
-        file.mention.text
-      ]);
-      const payloads = seen.get(key) ?? new Set;
-      if (payloads.has(file.data))
-        return [];
-      payloads.add(file.data);
-      seen.set(key, payloads);
-    }
-    const uri = file.source.type === "uri" ? file.source.uri : undefined;
-    const location = uri?.startsWith("file:") ? fileURLToPath(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
-            }
-          }
-        }
-      ];
+function containsHostInstance(value) {
+  if (isHostInstance(value))
+    return true;
+  if (Array.isArray(value))
+    return value.some(containsHostInstance);
+  if (value && typeof value === "object")
+    return Object.values(value).some(containsHostInstance);
+  return false;
+}
+function 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;
+}
+function contentKey(value) {
+  const plain = (entry) => {
+    if (ArrayBuffer.isView(entry)) {
+      return {
+        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
+      };
     }
-    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,
+function fileContentValue(result) {
+  const value = result?.value;
+  if (result?.type !== "content" || !Array.isArray(value))
+    return;
+  return value.some((item) => item?.type === "file") ? value : undefined;
+}
+function contentValueText(value) {
+  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
+`);
+}
+function contentValueAttachments(value) {
+  return value.filter((item) => item?.type === "file").map((item) => ({
+    type: "file",
+    mime: item.mime,
+    url: item.uri,
+    ...typeof item.name === "string" ? { filename: item.name } : {}
+  }));
+}
+function rebuildFileContent(value, output) {
+  if (isDroppedToolOutput(output))
+    return { type: "text", value: output };
+  const rebuilt = [];
+  let placed = false;
+  for (const item of value) {
+    if (item?.type !== "text") {
+      rebuilt.push(item);
+      continue;
+    }
+    if (placed)
+      continue;
+    placed = true;
+    rebuilt.push({ ...item, text: output });
+  }
+  if (!placed && output)
+    rebuilt.unshift({ type: "text", text: output });
+  return { type: "content", value: rebuilt };
+}
+function adaptPayload(draft, admittedIDs = new Set) {
+  const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
+  const source = draft.messages.filter((m) => !existingHeads.has(m.id));
+  const results = new Map;
+  const hostParts = new Map;
+  const hostPartTypes = new Set;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
+        const key = contentKey(part);
+        if (!hostParts.has(key))
+          hostParts.set(key, part);
+        hostPartTypes.add(part.type);
+      }
+      if (part.type === "tool-result" && typeof part.id === "string") {
+        const queue = results.get(part.id) ?? [];
+        queue.push({ part, message });
+        results.set(part.id, queue);
+      }
+    }
+  }
+  const paired = new Set;
+  const bridges = new Map;
+  const originals = new Map;
+  const bridgesByMessageID = new Map;
+  const bridgesByCarrier = new Map;
+  const originalsByID = new Map;
+  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
+  const nativeTool = (call, result) => {
+    const hostResult = result?.part.result;
+    const failed = result !== undefined && isToolError(result.part);
+    const value = hostResult?.value;
+    const files = fileContentValue(hostResult);
+    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
+    const part = {
+      type: "tool",
+      callID: call?.id ?? result?.part.id,
+      tool: call?.name ?? result?.part.name,
+      state: {
+        input: structuredClone(call?.input ?? {}),
+        status: failed ? "error" : result ? "completed" : "running",
+        ...result ? { output } : {},
+        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
+        ...files ? { attachments: contentValueAttachments(files) } : {}
+      }
+    };
+    bridges.set(part, {
+      call,
+      result: result?.part,
+      resultMessage: result?.message,
+      output,
+      files
+    });
+    if (result)
+      paired.add(result.part);
+    return part;
+  };
+  const convertedTool = (source) => {
+    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
+    const output = toolStateContent(sourceState);
+    const { content: _content, ...projectedState } = structuredClone(sourceState);
+    const part = {
+      type: "tool",
+      callID: source.callID ?? source.id,
+      tool: source.tool ?? source.name,
+      state: { ...projectedState, output }
+    };
+    bridges.set(part, { native: source, output });
+    return part;
+  };
+  const callParts = new Map;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type === "tool-call") {
+        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
+      } else if (part.type === "tool") {
+        callParts.set(part, convertedTool(part));
+      }
+    }
+  }
+  const messages = [];
+  for (const message of source) {
+    const parts = [];
+    for (const content of message.content) {
+      if (paired.has(content))
+        continue;
+      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
+      if (message.id && admittedIDs.has(message.id))
+        part.synthetic = true;
+      parts.push(part);
+    }
+    if (!parts.length && message.content.length)
+      continue;
+    const byCallID = new Map;
+    for (const part of parts) {
+      const bridge = bridges.get(part);
+      if (bridge && typeof part.callID === "string")
+        byCallID.set(part.callID, bridge);
+    }
+    if (typeof message.id === "string") {
+      bridgesByMessageID.set(message.id, byCallID);
+      originalsByID.set(message.id, message);
+    }
+    const mapped = {
+      info: {
+        id: message.id,
+        sessionID: draft.sessionID,
+        role: message.role,
+        ...{
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agent: draft.agent
+        }
+      },
+      parts
+    };
+    originals.set(mapped, message);
+    if (typeof message.id !== "string")
+      bridgesByCarrier.set(mapped, byCallID);
+    messages.push(mapped);
+  }
+  return {
+    messages,
+    commit() {
+      let head = 0;
+      const rendered = [];
+      const emptyTextGuard = modelAcceptsEmptyContent(draft.model.providerID);
+      let omitted = 0;
+      let emptyTextParts = 0;
+      for (const message of messages) {
+        const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
+        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
+        const content = [];
+        const following = [];
+        for (const candidate of message.parts) {
+          const part = candidate;
+          const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
+          if (!bridge) {
+            if (part.type === "tool") {
+              const state = part.state;
+              if (typeof part.callID !== "string" || typeof part.tool !== "string" || !state || typeof state !== "object") {
+                rejectContentPart(message, part, "tool has no call ID, name, or state");
+                continue;
+              }
+              content.push({
+                type: "tool-call",
+                id: part.callID,
+                name: part.tool,
+                input: state.input
+              });
+              if (state.status === "completed" || state.status === "error") {
+                following.push({
+                  role: "tool",
+                  content: [
+                    {
+                      type: "tool-result",
+                      id: part.callID,
+                      name: part.tool,
+                      result: {
+                        type: state.status === "error" ? "error" : "text",
+                        value: toolStateContent(state)
+                      }
+                    }
+                  ]
+                });
+              }
+              continue;
+            }
+            if (part.type === "file") {
+              const mime = part.mime;
+              const url = part.url;
+              const prefix = `data:${mime};base64,`;
+              if (typeof mime !== "string" || !/^image\/(png|jpeg|gif|webp)$/.test(mime) || typeof url !== "string" || !url.startsWith(prefix)) {
+                rejectContentPart(message, part, "file is not an inline supported image");
+                continue;
+              }
+              const asset = hostMediaAsset(url.slice(prefix.length), mime);
+              if (typeof asset === "string") {
+                rejectContentPart(message, part, `host media unavailable: ${asset}`);
+                continue;
+              }
+              content.push({ type: "media", media: asset });
+              continue;
+            }
+            if (!HOST_CONTENT_TYPES.has(String(part.type))) {
+              rejectContentPart(message, part, "unknown host content type");
+              continue;
+            }
+            const { synthetic: _synthetic, ...clean } = part;
+            const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
+            content.push(original ?? clean);
+            continue;
+          }
+          const state = part.state;
+          if (bridge.native) {
+            const native = bridge.native;
+            const callID = String(native.id ?? native.callID ?? part.callID);
+            const name = String(native.name ?? native.tool ?? part.tool);
+            content.push({ type: "tool-call", id: callID, name, input: state.input });
+            if (state.status === "completed" || state.status === "error") {
+              following.push({
+                role: "tool",
+                content: [
+                  {
+                    type: "tool-result",
+                    id: callID,
+                    name,
+                    result: {
+                      type: state.status === "error" ? "error" : "text",
+                      value: state.output
+                    }
+                  }
+                ]
+              });
+            }
+            continue;
+          }
+          if (bridge.call)
+            content.push({ ...bridge.call, input: state.input });
+          if (bridge.result && bridge.resultMessage) {
+            const result = {
+              ...bridge.result,
+              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
+                type: state.status === "error" ? "error" : "text",
+                value: state.output
+              }
+            };
+            if (bridge.resultMessage === original)
+              content.push(result);
+            else
+              following.push({ ...bridge.resultMessage, content: [result] });
+          }
+        }
+        const guarded = emptyTextGuard ? removeEmptyTextParts(content, rendered) : 0;
+        if (content.length || !original?.content.length && guarded === 0) {
+          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);
+        } else if (emptyTextGuard) {
+          omitted += 1;
+        }
+        emptyTextParts += guarded;
+        rendered.push(...following);
+      }
+      if (omitted + emptyTextParts > 0 && !emptyTextOmissionLogged.has(draft.sessionID)) {
+        emptyTextOmissionLogged.add(draft.sessionID);
+        sessionLog2(draft.sessionID, `v2 payload: left out ${omitted} emptied messages and ${emptyTextParts} empty text parts, because Anthropic rejects an empty text block (logged once per session)`);
+      }
+      draft.messages.splice(0, draft.messages.length, ...rendered);
+    }
+  };
+}
+
+// src/v2/fold/native-codec.ts
+class NativeReplayUnavailable extends Error {
+}
+function encodeNative(messages) {
+  for (const message of messages)
+    for (const part of message.content) {
+      if (part.type !== "media" || !part.media)
+        continue;
+      const asset = part.media;
+      if (typeof asset.toJSON !== "function" || asset.headers !== undefined)
+        throw new NativeReplayUnavailable("Native media has no lossless replay codec");
+      const encoded = asset.toJSON();
+      const revived = hostMediaFromEncoded(encoded);
+      if (typeof revived === "string" || JSON.stringify(revived) !== JSON.stringify(asset))
+        throw new NativeReplayUnavailable("Native media cannot be decoded losslessly before admission");
+    }
+  const encoded = JSON.parse(JSON.stringify(messages));
+  const freeze = (value) => {
+    if (!value || typeof value !== "object")
+      return;
+    for (const item of Object.values(value))
+      freeze(item);
+    Object.freeze(value);
+  };
+  freeze(encoded);
+  return encoded;
+}
+function reviveNative(messages) {
+  const result = structuredClone([...messages]);
+  for (const message of result)
+    for (const part of message.content) {
+      if (part.type !== "media" || !part.media)
+        continue;
+      const asset = hostMediaFromEncoded(part.media);
+      if (typeof asset === "string")
+        throw new NativeReplayUnavailable(asset);
+      part.media = asset;
+    }
+  return result;
+}
+
+// src/v2/fold/restore.ts
+import { fileURLToPath } from "node:url";
+
+// src/v2/hooks/storage-notice.ts
+var STORAGE_NOTICE_PREFIX = "[Magic Context storage notice] ";
+function formatStorageRefusalNotice(reason) {
+  return `${STORAGE_NOTICE_PREFIX}This turn was not sent to the model. ${formatFailClosedBlockingSummary(reason)}`;
+}
+function formatStorageRecoveryNotice(hiddenWorkRecovered) {
+  return hiddenWorkRecovered ? `${STORAGE_NOTICE_PREFIX}Magic Context storage is available again and turns are sent to the model. The historian and dreamer are running again. Restart OpenCode to enable Magic Context's tools.` : `${STORAGE_NOTICE_PREFIX}Magic Context storage is available again and turns are sent to the model. Restart OpenCode to enable Magic Context's tools, historian and dreamer.`;
+}
+function isStorageNoticeText(text) {
+  return typeof text === "string" && text.startsWith(STORAGE_NOTICE_PREFIX);
+}
+function hasStorageNoticeShape(message) {
+  if (message.role !== "user" || typeof message.id !== "string")
+    return false;
+  if (message.content.length !== 1)
+    return false;
+  const part = message.content[0];
+  return part?.type === "text" && isStorageNoticeText(part.text);
+}
+async function dropStorageNotices(messages, isAdmittedSynthetic) {
+  const drop = new Set;
+  for (const message of messages) {
+    if (!hasStorageNoticeShape(message))
+      continue;
+    if (await isAdmittedSynthetic(message.id))
+      drop.add(message);
+  }
+  if (drop.size === 0)
+    return 0;
+  const kept = messages.filter((message) => !drop.has(message));
+  messages.splice(0, messages.length, ...kept);
+  return drop.size;
+}
+
+// src/v2/fold/restore.ts
+function unavailableAttachmentNote(name, mediaType) {
+  return `[Attachment ${name ? `"${name}" ` : ""}(${mediaType}) is not available in this restored history]`;
+}
+var imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+function attachmentParts(files, rowID, media) {
+  const seen = new Map;
+  return files.flatMap((file) => {
+    if (imageMimes.has(file.mime) && file.source.type === "inline" && file.mention?.text) {
+      const key = JSON.stringify([
+        file.mime,
+        file.name ?? null,
+        file.description ?? null,
+        file.mention.text
+      ]);
+      const payloads = seen.get(key) ?? new Set;
+      if (payloads.has(file.data))
+        return [];
+      payloads.add(file.data);
+      seen.set(key, payloads);
+    }
+    const uri = file.source.type === "uri" ? file.source.uri : undefined;
+    const location = uri?.startsWith("file:") ? fileURLToPath(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) }
+      ];
+    }
+    return [...located, { type: "media", media: asset, filename: file.name, metadata }];
+  });
+}
+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") {
@@ -866,36 +1568,425 @@ ${data.output?.output ?? ""}`
     let input = state.input;
     if (state.status === "streaming" && typeof input === "string") {
       try {
-        input = JSON.parse(input);
-      } catch {}
+        input = JSON.parse(input);
+      } catch {}
+    }
+    content.push({
+      type: "tool-call",
+      id: part.id,
+      name: part.name,
+      input,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
+    });
+    if (!completed)
+      continue;
+    const toolContent = state.content ?? [];
+    const single = toolContent.length === 1 ? toolContent[0] : undefined;
+    const result = {
+      type: "tool-result",
+      id: part.id,
+      name: part.name,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : undefined,
+      result: state.status === "error" ? { error: state.error, content: toolContent } : single?.type === "text" ? { type: "text", value: single.text } : { type: "content", value: toolContent },
+      ...state.status === "error" ? { resultType: "error" } : {}
+    };
+    if (part.executed === true)
+      content.push(result);
+    else
+      results.push({ role: "tool", content: [result] });
+  }
+  return [...content.length ? [make("assistant", content)] : [], ...results];
+}
+
+// src/v2/fold/native-replay.ts
+var coordinates = new WeakMap;
+function nativeRowID(message) {
+  return coordinates.get(message) ?? message.id;
+}
+function copyNativeInput(messages) {
+  const copies = reviveNative(encodeNative(messages));
+  copies.forEach((copy, i) => {
+    const original = messages[i];
+    const id = original && nativeRowID(original);
+    if (id !== undefined)
+      coordinates.set(copy, id);
+  });
+  return copies;
+}
+function isLocalCheckpoint(row) {
+  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined;
+}
+var conversational = (row) => RAW_MESSAGE_TYPES.includes(row.type) || row.type === "location-switched";
+
+class NativeFoldReplay {
+  storage;
+  openReader;
+  changed = new Set;
+  dirty = new Set;
+  unavailable = new Set;
+  metadata = new Map;
+  metadataThrough = new Map;
+  loaded = new Map;
+  sources = new Map;
+  constructor(storage, openReader) {
+    this.storage = storage;
+    this.openReader = openReader;
+    storage.onEvict((sessionID) => this.clear(sessionID));
+  }
+  account(sessionID) {
+    const source = this.sources.get(sessionID);
+    let bytes = 256 + (source?.length ?? 0) * 2;
+    for (const row of this.metadata.get(sessionID) ?? [])
+      bytes += 128 + (row.id.length + row.type.length) * 2;
+    this.storage.accountReplay(sessionID, bytes);
+  }
+  async observeSource(sessionID, reader) {
+    const source = reader.hostIdentity();
+    const prior = this.sources.get(sessionID);
+    if (prior && prior !== source)
+      await this.forget(sessionID);
+    this.sources.set(sessionID, source);
+    this.account(sessionID);
+  }
+  onEvent(event) {
+    const sessionID = event.data?.sessionID;
+    if (sessionID && (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated"))
+      this.invalidate(sessionID);
+  }
+  invalidate(sessionID, suppressNomination = false) {
+    if (suppressNomination)
+      this.unavailable.add(sessionID);
+    this.dirty.add(sessionID);
+    this.changed.add(sessionID);
+    this.metadata.delete(sessionID);
+    this.metadataThrough.delete(sessionID);
+    this.account(sessionID);
+  }
+  tail(sessionID) {
+    const record = this.storage.tail(sessionID);
+    return record ? JSON.parse(record.data) : undefined;
+  }
+  async baseline(sessionID) {
+    return this.tail(sessionID)?.baseline;
+  }
+  rendered(row, model) {
+    return restoreRow(row, model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: () => {}
+    } : undefined);
+  }
+  record(row, messages) {
+    const data = JSON.stringify(encodeNative(messages));
+    return { id: row.id, type: row.type, seq: row.seq, data, digest: foldDigest(data) };
+  }
+  records(sessionID, native, reader) {
+    let metadata = this.metadata.get(sessionID);
+    const through = reader.latestSequence(sessionID);
+    const known = new Set(metadata?.map((row) => row.id));
+    if (!metadata || (this.metadataThrough.get(sessionID) ?? -1) < through || native.some((message) => message.id && !known.has(message.id))) {
+      metadata = reader.rowStampsThrough(sessionID, through).filter(conversational);
+      this.metadata.set(sessionID, metadata);
+      this.metadataThrough.set(sessionID, through);
+    }
+    const byID = new Map(metadata.map((row) => [row.id, row]));
+    const grouped = new Map;
+    const anchorIndex = native.findIndex((message) => {
+      const id = nativeRowID(message);
+      return id !== undefined && byID.has(id);
+    });
+    const leading = native.slice(0, anchorIndex < 0 ? native.length : anchorIndex).filter((message) => !nativeRowID(message) && message.role === "system");
+    const anchorMessage = native[anchorIndex];
+    const anchorID = anchorMessage && nativeRowID(anchorMessage);
+    const anchor = anchorID ? byID.get(anchorID) : undefined;
+    const leadingRows = anchor ? metadata.filter((row) => row.type === "system" && row.seq < anchor.seq).slice(-leading.length) : [];
+    const leadingIDs = new Map(leading.map((message, i) => [message, leadingRows[i]?.id]));
+    let cursor = -1;
+    let owner;
+    for (const message of native) {
+      let id = nativeRowID(message);
+      if (!id && message.role === "system") {
+        if (leadingIDs.has(message)) {
+          id = leadingIDs.get(message);
+          if (!id)
+            continue;
+        } else
+          id = metadata.find((row) => row.type === "system" && row.seq > cursor)?.id;
+      }
+      if (!id && message.role === "tool")
+        id = owner;
+      const row = id ? byID.get(id) : undefined;
+      if (!row)
+        throw new NativeReplayUnavailable("Native carrier has no source row coordinate");
+      cursor = row.seq;
+      coordinates.set(message, row.id);
+      if (message.role !== "tool")
+        owner = row.id;
+      const messages = grouped.get(row) ?? [];
+      messages.push(message);
+      grouped.set(row, messages);
+    }
+    return [...grouped].map(([row, messages]) => this.record(row, messages));
+  }
+  async capture(draft, native) {
+    const release = this.storage.hold(draft.sessionID);
+    try {
+      rememberHostMedia(native);
+      const reader = this.openReader(draft.sessionID);
+      try {
+        const rows = this.records(draft.sessionID, native, reader);
+        const baseline = draft.messages.find((message) => message.id === HEAD_IDS[0])?.content.find((part) => part.type === "text")?.text;
+        const through = Math.max(-1, ...rows.map((row) => row.seq));
+        const tail = {
+          model: `${draft.model.providerID}/${draft.model.id}`,
+          sourceSeq: through,
+          baseline: typeof baseline === "string" ? baseline : this.tail(draft.sessionID)?.baseline
+        };
+        await this.storage.saveTail(draft.sessionID, JSON.stringify(tail), rows);
+        this.storage.truncate(draft.sessionID, through);
+        this.loaded.set(draft.sessionID, through);
+        this.unavailable.delete(draft.sessionID);
+        this.changed.delete(draft.sessionID);
+      } finally {
+        reader.close();
+      }
+    } catch {
+      this.unavailable.add(draft.sessionID);
+      this.invalidate(draft.sessionID);
+    } finally {
+      this.account(draft.sessionID);
+      release();
+    }
+  }
+  async canReplay(sessionID, _reader) {
+    return !this.unavailable.has(sessionID) && typeof await this.baseline(sessionID) === "string";
+  }
+  async supply(args) {
+    const release = this.storage.hold(args.draft.sessionID);
+    try {
+      return await this.supplyHeld(args);
+    } finally {
+      this.account(args.draft.sessionID);
+      release();
+    }
+  }
+  async supplyHeld(args) {
+    const { draft, reader, summary } = args;
+    const tail = this.tail(draft.sessionID);
+    const id = reader.latestRunningCompaction(draft.sessionID)?.id;
+    if (!id || !tail || tail.model !== `${draft.model.providerID}/${draft.model.id}`)
+      return false;
+    const through = reader.latestSequence(draft.sessionID);
+    const after = this.dirty.has(draft.sessionID) ? -1 : tail.sourceSeq;
+    const fresh = reader.range(draft.sessionID, after, through).filter(conversational);
+    const records = fresh.map((row) => this.record(row, this.rendered(row, draft.model)));
+    if (this.dirty.has(draft.sessionID))
+      this.storage.replaceRows(draft.sessionID, through, records);
+    await this.storage.saveTail(draft.sessionID, JSON.stringify({
+      ...tail,
+      sourceSeq: Math.max(tail.sourceSeq, ...fresh.map((row) => row.seq))
+    }), records);
+    this.dirty.delete(draft.sessionID);
+    this.metadata.delete(draft.sessionID);
+    this.metadataThrough.delete(draft.sessionID);
+    this.loaded.set(draft.sessionID, through);
+    const snapshot = {
+      source: this.storage.sourceID,
+      sessionID: draft.sessionID,
+      admissionID: id,
+      summary
+    };
+    await this.storage.supply(draft.sessionID, id, JSON.stringify(snapshot));
+    return true;
+  }
+  async restore(sessionID, cut, model, options = {}) {
+    const release = this.storage.hold(sessionID);
+    try {
+      return await this.restoreHeld(sessionID, cut, model, options);
+    } finally {
+      this.account(sessionID);
+      release();
+    }
+  }
+  async restoreHeld(sessionID, cut, model, options) {
+    if (!isLocalCheckpoint(cut))
+      return;
+    const resolvedModel = {
+      providerID: model.slice(0, model.indexOf("/")),
+      id: model.slice(model.indexOf("/") + 1)
+    };
+    const tail = this.tail(sessionID);
+    if (tail && tail.model !== model)
+      this.invalidate(sessionID);
+    let after = options.after ?? -1;
+    if (options.bounded && options.after === undefined && !this.changed.has(sessionID)) {
+      const state = getOrCreateSessionMeta(this.storage.db, sessionID);
+      const max = this.storage.db.prepare("SELECT COALESCE(MAX(id),0) AS id FROM m0_mutation_log WHERE session_id=?").get(sessionID);
+      const boundary = this.storage.db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id=?").get(sessionID)?.id;
+      if (max.id <= (state.cachedM0MaxMutationId ?? 0) && boundary)
+        after = this.storage.sequenceForID(sessionID, boundary) ?? -1;
+    }
+    const through = cut.seq - 1;
+    let reader;
+    try {
+      let metadata = this.metadata.get(sessionID);
+      if (!metadata || (this.metadataThrough.get(sessionID) ?? -1) < through) {
+        reader = this.openReader(sessionID);
+        metadata = reader.rowStampsThrough(sessionID, through).filter(conversational);
+        this.metadata.set(sessionID, metadata);
+        this.metadataThrough.set(sessionID, through);
+      }
+      const required = metadata.filter((row) => row.seq > after && row.seq <= through);
+      if (this.dirty.has(sessionID) || !tail || (this.loaded.get(sessionID) ?? -1) < through && !this.storage.admission(sessionID, cut.id) || !this.storage.containsRows(sessionID, required.map((row) => row.id))) {
+        reader ??= this.openReader(sessionID);
+        const fresh = reader.range(sessionID, after, through).filter(conversational);
+        const records = fresh.map((row) => this.record(row, this.rendered(row, resolvedModel)));
+        const restored = new Set(records.map((row) => row.id));
+        if (required.some((row) => !restored.has(row.id)))
+          throw new NativeReplayUnavailable("Host restore omitted a required source row");
+        this.storage.replaceRows(sessionID, through, records, after);
+        await this.storage.saveTail(sessionID, JSON.stringify({
+          model,
+          sourceSeq: through,
+          baseline: tail?.baseline ?? cut.data.summary
+        }), []);
+        this.loaded.set(sessionID, through);
+        this.dirty.delete(sessionID);
+      }
+    } finally {
+      reader?.close();
+    }
+    const messages = [];
+    for (const row of this.storage.rows(sessionID, after, cut.seq - 1)) {
+      const revived = reviveNative(JSON.parse(row.data));
+      for (const message of revived)
+        coordinates.set(message, row.id);
+      messages.push(...revived);
+    }
+    return messages;
+  }
+  async restoreRead(sessionID, cut, model) {
+    const reader = this.openReader(sessionID);
+    try {
+      return reader.range(sessionID, -1, cut.seq - 1).filter(conversational).flatMap((row) => {
+        const messages = this.rendered(row, model);
+        for (const message of messages)
+          coordinates.set(message, row.id);
+        return messages;
+      });
+    } finally {
+      reader.close();
+    }
+  }
+  sourceChanged(sessionID) {
+    return this.changed.has(sessionID);
+  }
+  clear(sessionID) {
+    this.sources.delete(sessionID);
+    this.metadata.delete(sessionID);
+    this.metadataThrough.delete(sessionID);
+    this.loaded.delete(sessionID);
+    this.unavailable.delete(sessionID);
+    this.dirty.delete(sessionID);
+    this.changed.delete(sessionID);
+  }
+  async forget(sessionID) {
+    await this.storage.forget(sessionID);
+  }
+}
+
+// src/v2/fold/policy.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+class HostFoldPolicy {
+  deps;
+  active = new Set;
+  owner = randomUUID2();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  owned(sessionID, cut, id) {
+    const row = this.deps.storage.admission(sessionID, id);
+    if (!isLocalCheckpoint(cut) || cut.id !== id || !row?.payload || row.digest !== foldDigest(row.payload))
+      return false;
+    const snapshot = JSON.parse(row.payload);
+    return snapshot.summary === cut.data.summary && snapshot.source === this.deps.storage.sourceID && snapshot.sessionID === sessionID && snapshot.admissionID === id;
+  }
+  async idle(sessionID) {
+    const { storage, session, threshold } = this.deps;
+    if (!Number.isSafeInteger(threshold) || threshold <= 0 || typeof session.compact !== "function" || this.active.has(sessionID))
+      return;
+    this.active.add(sessionID);
+    const now = this.deps.now ?? Date.now;
+    let attempt;
+    let claimed = false;
+    try {
+      const reader = this.deps.openReader();
+      try {
+        const cut = reader.latestCompaction(sessionID);
+        const previous = storage.latestAttempt(sessionID);
+        const old = previous ? JSON.parse(previous.data) : undefined;
+        if (cut && previous?.status === "pending" && old && this.owned(sessionID, cut, old.id)) {
+          if (await storage.claim(sessionID, old.id, previous.data, this.owner, now()) && await storage.finish(sessionID, old.id, this.owner, "completed", now()))
+            this.deps.log(sessionID, `v2 host fold: rows_before=${old.before} rows_after=${reader.storedRowsAfter(sessionID, cut.seq)} duration_ms=${now() - old.started} reason=row_threshold id=${cut.id} status=completed`);
+          return;
+        }
+        const after = cut?.seq ?? -1;
+        const before = reader.storedRowsAfter(sessionID, after);
+        if (before < threshold || !await this.deps.canReplay(sessionID, reader))
+          return;
+        const retry = old?.after === after ? old.attempt + (previous?.status === "failed" || previous?.status === "coalesced" ? 1 : 0) : 0;
+        const id = old?.after === after && previous?.status === "pending" ? old.id : `msg_mc_fold_${foldDigest(`${storage.sourceID}/${sessionID}/${after}/${retry}`).slice(0, 24)}`;
+        attempt = {
+          after,
+          before,
+          watermark: reader.latestSequence(sessionID),
+          attempt: retry,
+          id,
+          started: now()
+        };
+        claimed = await storage.claim(sessionID, id, JSON.stringify(attempt), this.owner, now());
+        if (!claimed)
+          return;
+      } finally {
+        reader.close();
+      }
+      const admitted = await session.compact({
+        sessionID,
+        id: attempt.id,
+        delivery: "queue"
+      });
+      await session.wait({ sessionID });
+      const settled = this.deps.openReader();
+      try {
+        const cut = settled.latestCompaction(sessionID);
+        if (admitted?.id !== attempt.id || !cut || cut.seq <= attempt.after || !this.owned(sessionID, cut, attempt.id)) {
+          if (await storage.finish(sessionID, attempt.id, this.owner, "coalesced", now()))
+            this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=unknown duration_ms=${now() - attempt.started} reason=row_threshold id=${attempt.id} actual_id=${cut?.id ?? admitted?.id ?? "unknown"} status=coalesced`);
+          return;
+        }
+        const after = settled.storedRowsAfter(sessionID, cut.seq);
+        if (await storage.finish(sessionID, attempt.id, this.owner, "completed", now()))
+          this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=${after} duration_ms=${now() - attempt.started} reason=row_threshold id=${cut.id} status=completed`);
+      } finally {
+        settled.close();
+      }
+    } catch (error) {
+      if (claimed && attempt) {
+        let finished = false;
+        try {
+          finished = await storage.finish(sessionID, attempt.id, this.owner, "failed", now());
+        } catch {
+          finished = true;
+        }
+        if (finished)
+          this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=unknown duration_ms=${now() - attempt.started} reason=row_threshold id=${attempt.id} status=failed error=${JSON.stringify(String(error))}`);
+      } else
+        this.deps.log(sessionID, `v2 host fold: rows_before=unknown rows_after=unknown duration_ms=0 reason=row_threshold status=failed error=${JSON.stringify(String(error))} cache_error=${JSON.stringify(String(error))}`);
+    } finally {
+      this.active.delete(sessionID);
     }
-    content.push({
-      type: "tool-call",
-      id: part.id,
-      name: part.name,
-      input,
-      providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
-    });
-    if (!completed)
-      continue;
-    const toolContent = state.content ?? [];
-    const single = toolContent.length === 1 ? toolContent[0] : undefined;
-    const result = {
-      type: "tool-result",
-      id: part.id,
-      name: part.name,
-      providerExecuted: part.executed,
-      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : undefined,
-      result: state.status === "error" ? { error: state.error, content: toolContent } : single?.type === "text" ? { type: "text", value: single.text } : { type: "content", value: toolContent },
-      ...state.status === "error" ? { resultType: "error" } : {}
-    };
-    if (part.executed === true)
-      content.push(result);
-    else
-      results.push({ role: "tool", content: [result] });
   }
-  return [...content.length ? [make("assistant", content)] : [], ...results];
 }
 
 // src/v2/fork-inheritance.ts
@@ -1459,7 +2550,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
   const runs = new WeakMap;
   const generation = options.generation ?? "opencode2";
   const roleTails = new Map;
-  const note = options.log ?? log;
+  const note = options.log ?? log2;
   const removeSession = host.removeSession;
   if (!removeSession)
     throw new Error("Magic Context requires OpenCode 2.0.22 session.remove");
@@ -1694,7 +2785,8 @@ async function createV2HiddenCompletionExecutor(host, options) {
           ...budget ? [budgetStopped] : []
         ]);
         if (!attempt.shaped) {
-          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Host did not dispatch the hidden child context hook", true);
+          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;
@@ -1829,7 +2921,7 @@ async function deliverPendingChannel2(context, db, sessionID, baseline) {
 async function registerV2Commands(args) {
   const domain = args.command;
   if (!domain || typeof domain.transform !== "function") {
-    log("[magic-context] v2 host exposes no command domain; /ctx-* commands are TUI-only");
+    log2("[magic-context] v2 host exposes no command domain; /ctx-* commands are TUI-only");
     return false;
   }
   const descriptions = getMagicContextBuiltinCommands(args.compactionEnabled);
@@ -1845,10 +2937,10 @@ async function registerV2Commands(args) {
       }
     });
   } catch (error) {
-    log("[magic-context] v2 command registration failed", error);
+    log2("[magic-context] v2 command registration failed", error);
     return false;
   }
-  log(`[magic-context] registered server-side commands: ${commands.map((command) => command.name).join(" ")}`);
+  log2(`[magic-context] registered server-side commands: ${commands.map((command) => command.name).join(" ")}`);
   return true;
 }
 function commandArgument(input, name) {
@@ -1918,6 +3010,10 @@ function buildV2Commands(rpc, directory) {
           const error = typeof reply.error === "string" ? reply.error : "dream request failed";
           throw new Error(`Magic Context could not start the dream run: ${error}`);
         }
+        pushNotification2("toast", {
+          message: "Dream run started; the summary appears when it finishes",
+          variant: "info"
+        }, input.sessionID);
       }
     },
     {
@@ -1925,702 +3021,328 @@ function buildV2Commands(rpc, directory) {
       execute: async (input) => {
         const reply = await rpc.dispatch("flush", { sessionId: input.sessionID });
         reportRpcReply(input.sessionID, "Flush", reply, "Flush started");
+        if (reply.ok === true) {
+          pushNotification2("action", { action: "refresh-sidebar" }, input.sessionID);
+        }
       }
     },
     {
       name: "ctx-embed",
       execute: async (input) => {
         const argument = commandArgument(input, "ctx-embed").toLowerCase();
-        if (argument !== "" && argument !== "start" && argument !== "pause") {
-          reportUsage(input.sessionID, "Usage: /ctx-embed (status), /ctx-embed start, or /ctx-embed pause");
-          throw new Error("Usage: /ctx-embed (status), /ctx-embed start, or /ctx-embed pause");
-        }
-        const reply = await rpc.dispatch("embed", {
-          sessionId: input.sessionID,
-          action: argument === "" ? "status" : argument,
-          directory
-        });
-        reportRpcReply(input.sessionID, "Embed", reply, "Embedding started; the summary appears when it finishes");
-      }
-    },
-    {
-      name: "ctx-wrapup",
-      execute: async (input) => {
-        const argument = commandArgument(input, "ctx-wrapup");
-        if (argument !== "" && !/^\d+$/.test(argument)) {
-          const usage = "Usage: /ctx-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");
-      }
-    }
-  ];
-}
-
-// 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/retrospective-raw-provider.ts
-class V2RetrospectiveRawProvider {
-  contextDb;
-  openReader;
-  reader;
-  constructor(contextDb, openReader = () => new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"))) {
-    this.contextDb = contextDb;
-    this.openReader = openReader;
-  }
-  store() {
-    return this.reader ??= this.openReader();
-  }
-  listProjectSessions(projectIdentity) {
-    const sessions = this.contextDb.prepare(`
-            SELECT sp.session_id FROM session_projects sp
-            LEFT JOIN session_meta m ON m.session_id = sp.session_id
-            WHERE sp.project_path = ? AND sp.harness = 'opencode2'
-                AND COALESCE(m.is_subagent, 0) = 0
-            ORDER BY sp.session_id`).all(projectIdentity);
-    const roots = this.store().rootSessionActivity(sessions.map((row) => row.session_id));
-    return sessions.filter((row) => roots.has(row.session_id)).map((row) => ({ sessionId: row.session_id, updatedAt: roots.get(row.session_id) }));
-  }
-  readOldestMessageTimesSince(sessionIds, sinceMs) {
-    return this.store().oldestUserMessageTimesSince(sessionIds, sinceMs);
-  }
-  read(sessionId, boundaryMs, limit, before = false) {
-    return this.store().retrospectiveUserPage(sessionId, {
-      boundaryMs,
-      before,
-      limit,
-      maxChars: RETROSPECTIVE_MAX_USER_MESSAGE_CHARS,
-      truncationMarker: RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER
-    }).map((row) => ({
-      sessionId,
-      ordinal: row.seq,
-      role: "user",
-      text: cleanUserText2(row.text),
-      ts: row.time_created
-    }));
-  }
-  readUserMessagesSince(sessionId, sinceMs, capPerSession) {
-    const cap = Math.max(1, Math.min(9999, Math.floor(capPerSession)));
-    const rows = this.read(sessionId, sinceMs, cap + 1);
-    return { messages: rows.slice(0, cap), truncated: rows.length > cap };
-  }
-  readUserMessagesBefore(sessionId, beforeMs, count) {
-    return this.read(sessionId, beforeMs, Math.max(1, Math.min(1e4, Math.floor(count))), true).reverse().filter((row) => hasMeaningfulUserText2([{ type: "text", text: row.text }]));
-  }
-  dispose() {
-    this.reader?.close();
-    this.reader = undefined;
-  }
-}
-
-// src/v2/hooks/dream-manual.ts
-function resolveManualDreamTask(raw) {
-  const requested = typeof raw === "string" ? raw.trim() : "";
-  if (!requested)
-    return {};
-  if (!isCanonicalDreamTask(requested)) {
-    return {
-      error: `Unknown task "${requested}". Valid tasks: ${CANONICAL_DREAM_TASKS.join(", ")}.`
-    };
-  }
-  return { task: requested };
-}
-function selectRunnableDreamTasks(args) {
-  const requiresTools = (task) => DREAM_TASK_CAPABILITIES[task].requiresTools;
-  if (args.toolsSupported)
-    return { runnable: [...args.tasks], unsupported: [] };
-  if (args.requestedTask !== undefined) {
-    if (requiresTools(args.requestedTask)) {
-      return { runnable: [], unsupported: [args.requestedTask] };
-    }
-    return {
-      runnable: args.tasks.filter((config) => config.task === args.requestedTask),
-      unsupported: []
-    };
-  }
-  const unsupported = args.tasks.filter((config) => config.schedule.trim() !== "" && requiresTools(config.task)).map((config) => config.task);
-  return {
-    runnable: args.tasks.filter((config) => !requiresTools(config.task)),
-    unsupported
-  };
-}
-async function runManualDreamNow(args) {
-  const tasks = buildDreamTaskRuntimeConfigs2(args.dreamer, "opencode", args.language, args.mural?.model);
-  const executor = createDreamTaskExecutor({
-    hiddenCompletionExecutor: args.executor,
-    parentSessionId: args.sessionId,
-    sessionDirectory: args.directory,
-    openOpenCodeDb: () => null,
-    retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
-    language: args.language,
-    mural: args.mural
-  });
-  const selection = selectRunnableDreamTasks({
-    tasks,
-    toolsSupported: args.executor.capabilities.tools === true,
-    ...args.task !== undefined ? { requestedTask: args.task } : {}
-  });
-  const summary = await runManualDream({
-    db: args.db,
-    projectIdentity: args.projectIdentity,
-    tasks: selection.runnable,
-    executor,
-    ...args.task !== undefined ? { task: args.task } : {}
-  });
-  return { summary, unsupportedTasks: selection.unsupported };
-}
-
-// src/v2/hooks/dream-timer.ts
-function findV2DreamParentSession(openReader, directory) {
-  let reader;
-  try {
-    reader = openReader();
-    const parent = reader.latestRootSessionInDirectory(directory);
-    if (!parent) {
-      log(`[dreamer] no OpenCode 2 session in ${directory} to parent a timer-started dream run; tasks that need a child session are skipped until one exists`);
-    }
-    return parent;
-  } catch (error) {
-    log(`[dreamer] OpenCode 2 parent session lookup failed for ${directory}:`, error);
-    return;
-  } finally {
-    reader?.close();
-  }
-}
-function registerV2DreamScheduleTimer(args) {
-  const { config, directory, dreamer, executor } = args;
-  const gitCommitIndexing = config.memory.git_commit_indexing;
-  let disposed = false;
-  const registration = startDreamScheduleTimer({
-    directory,
-    projectIdentity: args.projectIdentity,
-    harness: "opencode",
-    hiddenCompletionExecutor: executor,
-    findParentSessionId: () => findV2DreamParentSession(args.openReader, directory),
-    openOpenCodeDb: () => null,
-    retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
-    dreamerConfig: dreamer,
-    sampleDreamRun: () => {
-      const current = dreamerRunConfig(config, args.liveConfig());
-      return { dreamerConfig: current.dreamer ?? dreamer, mural: current.mural };
+        if (argument !== "" && argument !== "start" && argument !== "pause") {
+          reportUsage(input.sessionID, "Usage: /ctx-embed (status), /ctx-embed start, or /ctx-embed pause");
+          return;
+        }
+        const reply = await rpc.dispatch("embed", {
+          sessionId: input.sessionID,
+          action: argument === "" ? "status" : argument,
+          directory
+        });
+        reportRpcReply(input.sessionID, "Embed", reply, "Embedding started; the summary appears when it finishes");
+      }
     },
-    validateTaskModels: (tasks) => selectRunnableDreamTasks({ tasks, toolsSupported: executor.capabilities.tools }).runnable,
-    language: config.language,
-    mural: config.mural,
-    memoryEnabled: config.memory.enabled === true,
-    memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
-    retinaHandoff: config.smart_notes.retina_handoff,
-    embeddingConfig: config.embedding,
-    gitCommitIndexing: gitCommitIndexing?.enabled ? {
-      enabled: true,
-      since_days: gitCommitIndexing.since_days,
-      max_commits: gitCommitIndexing.max_commits
-    } : undefined,
-    ensureRegistered: ensureProjectRegisteredFromOpenCodeDirectory
-  }).catch((error) => {
-    log(`[magic-context] v2 dream timer registration failed (continuing without it): ${error}`);
-    return;
-  });
-  return {
-    async dispose() {
-      if (disposed)
-        return;
-      disposed = true;
-      const stop = await registration;
-      stop?.();
-    }
-  };
-}
-
-// src/v2/hooks/dream-trigger.ts
-async function sessionInThisLocation(context, sessionID) {
-  let location;
-  try {
-    location = (await context.session.get({ sessionID })).location;
-  } catch {
-    return false;
-  }
-  return location?.directory === context.location.directory && (location.workspaceID ?? "") === (context.location.workspaceID ?? "");
-}
-function startDreamTrigger(context, args) {
-  const controller = new AbortController;
-  const done = (async () => {
-    try {
-      for await (const value of context.event.subscribe({ signal: controller.signal })) {
-        if (controller.signal.aborted)
-          break;
-        const event = value;
-        if (event.type !== "session.execution.succeeded" || !event.data?.sessionID)
-          continue;
-        if (!await sessionInThisLocation(context, event.data.sessionID))
-          continue;
-        const db = openCurrentDatabase();
-        if (!db)
-          continue;
-        try {
-          const reader = args.openReader?.() ?? new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
-          try {
-            const activity = reader.rootSessionActivity([event.data.sessionID]).get(event.data.sessionID);
-            if (activity !== undefined)
-              advanceSessionActivity(db, event.data.sessionID, activity);
-          } finally {
-            reader.close();
-          }
-          const sampled = args.sample?.();
-          if ((sampled?.config ?? args.config).disable === true)
-            continue;
-          const { runnable } = selectRunnableDreamTasks({
-            tasks: buildDreamTaskRuntimeConfigs2(sampled?.config ?? args.config, "opencode", args.language, (sampled?.mural ?? args.mural)?.model),
-            toolsSupported: args.executor.capabilities.tools === true
-          });
-          await runDueTasksForProject({
-            db,
-            projectIdentity: args.projectIdentity(),
-            projectMemoryEnabled: args.projectMemoryEnabled,
-            tasks: runnable,
-            executor: createDreamTaskExecutor({
-              hiddenCompletionExecutor: args.executor,
-              parentSessionId: event.data.sessionID,
-              sessionDirectory: context.location.directory,
-              openOpenCodeDb: () => null,
-              retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
-              language: args.language,
-              mural: sampled?.mural ?? args.mural
-            })
-          });
-        } catch (error) {
-          log("[magic-context] v2 dream scheduling failed", error);
+    {
+      name: "ctx-wrapup",
+      execute: async (input) => {
+        const argument = commandArgument(input, "ctx-wrapup");
+        if (argument !== "" && !/^\d+$/.test(argument)) {
+          const usage = "Usage: /ctx-wrapup [messages_to_keep] where messages_to_keep is a positive integer";
+          reportUsage(input.sessionID, usage);
+          return;
+        }
+        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);
+          return;
         }
+        const reply = await rpc.dispatch("wrapup", {
+          sessionId: input.sessionID,
+          messagesToKeep
+        });
+        reportRpcReply(input.sessionID, "Wrapup", reply, "Wrapup started; the summary appears when it finishes");
       }
-    } catch (error) {
-      if (!controller.signal.aborted)
-        log("[magic-context] v2 dream event subscription failed", error);
-    }
-  })();
-  return {
-    async dispose() {
-      controller.abort();
-      await done;
     }
-  };
+  ];
 }
 
-// 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/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/payload.ts
-var HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
-var HOST_CONTENT_TYPES = new Set([
-  "text",
-  "media",
-  "tool-call",
-  "tool-result",
-  "reasoning",
-  "compaction",
-  "effort"
-]);
-function rejectContentPart(message, part, reason) {
-  const type = typeof part.type === "string" ? part.type : "<missing>";
-  const text = `v2 context omitted a content part the host would reject: type=${type} message=${String(message.info.id ?? "<head>")} reason=${reason}`;
-  if (typeof message.info.sessionID === "string")
-    sessionLog(message.info.sessionID, text);
-  else
-    log(text);
-}
-function isHostInstance(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype !== Object.prototype && prototype !== null;
-}
-function containsHostInstance(value) {
-  if (isHostInstance(value))
-    return true;
-  if (Array.isArray(value))
-    return value.some(containsHostInstance);
-  if (value && typeof value === "object")
-    return Object.values(value).some(containsHostInstance);
-  return false;
+// src/v2/retrospective-raw-provider.ts
+class V2RetrospectiveRawProvider {
+  contextDb;
+  openReader;
+  reader;
+  constructor(contextDb, openReader = () => new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"))) {
+    this.contextDb = contextDb;
+    this.openReader = openReader;
+  }
+  store() {
+    return this.reader ??= this.openReader();
+  }
+  listProjectSessions(projectIdentity) {
+    const sessions = this.contextDb.prepare(`
+            SELECT sp.session_id FROM session_projects sp
+            LEFT JOIN session_meta m ON m.session_id = sp.session_id
+            WHERE sp.project_path = ? AND sp.harness = 'opencode2'
+                AND COALESCE(m.is_subagent, 0) = 0
+            ORDER BY sp.session_id`).all(projectIdentity);
+    const roots = this.store().rootSessionActivity(sessions.map((row) => row.session_id));
+    return sessions.filter((row) => roots.has(row.session_id)).map((row) => ({ sessionId: row.session_id, updatedAt: roots.get(row.session_id) }));
+  }
+  readOldestMessageTimesSince(sessionIds, sinceMs) {
+    return this.store().oldestUserMessageTimesSince(sessionIds, sinceMs);
+  }
+  read(sessionId, boundaryMs, limit, before = false) {
+    return this.store().retrospectiveUserPage(sessionId, {
+      boundaryMs,
+      before,
+      limit,
+      maxChars: RETROSPECTIVE_MAX_USER_MESSAGE_CHARS,
+      truncationMarker: RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER
+    }).map((row) => ({
+      sessionId,
+      ordinal: row.seq,
+      role: "user",
+      text: cleanUserText2(row.text),
+      ts: row.time_created
+    }));
+  }
+  readUserMessagesSince(sessionId, sinceMs, capPerSession) {
+    const cap = Math.max(1, Math.min(9999, Math.floor(capPerSession)));
+    const rows = this.read(sessionId, sinceMs, cap + 1);
+    return { messages: rows.slice(0, cap), truncated: rows.length > cap };
+  }
+  readUserMessagesBefore(sessionId, beforeMs, count) {
+    return this.read(sessionId, beforeMs, Math.max(1, Math.min(1e4, Math.floor(count))), true).reverse().filter((row) => hasMeaningfulUserText2([{ type: "text", text: row.text }]));
+  }
+  dispose() {
+    this.reader?.close();
+    this.reader = undefined;
+  }
 }
-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;
+
+// src/v2/hooks/dream-manual.ts
+function resolveManualDreamTask(raw) {
+  const requested = typeof raw === "string" ? raw.trim() : "";
+  if (!requested)
+    return {};
+  if (!isCanonicalDreamTask(requested)) {
+    return {
+      error: `Unknown task "${requested}". Valid tasks: ${CANONICAL_DREAM_TASKS.join(", ")}.`
+    };
   }
-  return value;
+  return { task: requested };
 }
-function contentKey(value) {
-  const plain = (entry) => {
-    if (ArrayBuffer.isView(entry)) {
-      return {
-        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
-      };
-    }
-    if (Array.isArray(entry))
-      return entry.map(plain);
-    if (entry && typeof entry === "object") {
-      return Object.fromEntries(Object.entries(entry).map(([key, nested]) => [key, plain(nested)]));
+function selectRunnableDreamTasks(args) {
+  const requiresTools = (task) => DREAM_TASK_CAPABILITIES[task].requiresTools;
+  if (args.toolsSupported)
+    return { runnable: [...args.tasks], unsupported: [] };
+  if (args.requestedTask !== undefined) {
+    if (requiresTools(args.requestedTask)) {
+      return { runnable: [], unsupported: [args.requestedTask] };
     }
-    return entry;
+    return {
+      runnable: args.tasks.filter((config) => config.task === args.requestedTask),
+      unsupported: []
+    };
+  }
+  const unsupported = args.tasks.filter((config) => config.schedule.trim() !== "" && requiresTools(config.task)).map((config) => config.task);
+  return {
+    runnable: args.tasks.filter((config) => !requiresTools(config.task)),
+    unsupported
   };
-  return JSON.stringify(plain(value));
-}
-function fileContentValue(result) {
-  const value = result?.value;
-  if (result?.type !== "content" || !Array.isArray(value))
-    return;
-  return value.some((item) => item?.type === "file") ? value : undefined;
-}
-function contentValueText(value) {
-  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
-`);
 }
-function contentValueAttachments(value) {
-  return value.filter((item) => item?.type === "file").map((item) => ({
-    type: "file",
-    mime: item.mime,
-    url: item.uri,
-    ...typeof item.name === "string" ? { filename: item.name } : {}
-  }));
+async function runManualDreamNow(args) {
+  const tasks = buildDreamTaskRuntimeConfigs2(args.dreamer, "opencode", args.language, args.smartNotesEnabled);
+  const executor = createDreamTaskExecutor({
+    hiddenCompletionExecutor: args.executor,
+    parentSessionId: args.sessionId,
+    sessionDirectory: args.directory,
+    openOpenCodeDb: () => null,
+    retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
+    language: args.language,
+    mural: args.mural,
+    smartNotesEnabled: args.smartNotesEnabled
+  });
+  const selection = selectRunnableDreamTasks({
+    tasks,
+    toolsSupported: args.executor.capabilities.tools === true,
+    ...args.task !== undefined ? { requestedTask: args.task } : {}
+  });
+  const summary = await runManualDream({
+    db: args.db,
+    projectIdentity: args.projectIdentity,
+    tasks: selection.runnable,
+    executor,
+    ...args.task !== undefined ? { task: args.task } : {}
+  });
+  return { summary, unsupportedTasks: selection.unsupported };
 }
-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;
+
+// src/v2/hooks/dream-timer.ts
+function findV2DreamParentSession(openReader, directory) {
+  let reader;
+  try {
+    reader = openReader();
+    const parent = reader.latestRootSessionInDirectory(directory);
+    if (!parent) {
+      log2(`[dreamer] no OpenCode 2 session in ${directory} to parent a timer-started dream run; tasks that need a child session are skipped until one exists`);
     }
-    if (placed)
-      continue;
-    placed = true;
-    rebuilt.push({ ...item, text: output });
+    return parent;
+  } catch (error) {
+    log2(`[dreamer] OpenCode 2 parent session lookup failed for ${directory}:`, error);
+    return;
+  } finally {
+    reader?.close();
   }
-  if (!placed && output)
-    rebuilt.unshift({ type: "text", text: output });
-  return { type: "content", value: rebuilt };
 }
-function adaptPayload(draft, admittedIDs = new Set) {
-  const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
-  const source = draft.messages.filter((m) => !existingHeads.has(m.id));
-  const results = new Map;
-  const hostParts = new Map;
-  const hostPartTypes = new Set;
-  for (const message of source) {
-    for (const part of message.content) {
-      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
-        const key = contentKey(part);
-        if (!hostParts.has(key))
-          hostParts.set(key, part);
-        hostPartTypes.add(part.type);
-      }
-      if (part.type === "tool-result" && typeof part.id === "string") {
-        const queue = results.get(part.id) ?? [];
-        queue.push({ part, message });
-        results.set(part.id, queue);
-      }
-    }
-  }
-  const paired = new Set;
-  const bridges = new Map;
-  const originals = new Map;
-  const bridgesByMessageID = new Map;
-  const bridgesByCarrier = new Map;
-  const originalsByID = new Map;
-  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
-  const nativeTool = (call, result) => {
-    const hostResult = result?.part.result;
-    const failed = result !== undefined && isToolError(result.part);
-    const value = hostResult?.value;
-    const files = fileContentValue(hostResult);
-    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
-    const part = {
-      type: "tool",
-      callID: call?.id ?? result?.part.id,
-      tool: call?.name ?? result?.part.name,
-      state: {
-        input: structuredClone(call?.input ?? {}),
-        status: failed ? "error" : result ? "completed" : "running",
-        ...result ? { output } : {},
-        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
-        ...files ? { attachments: contentValueAttachments(files) } : {}
-      }
-    };
-    bridges.set(part, {
-      call,
-      result: result?.part,
-      resultMessage: result?.message,
-      output,
-      files
-    });
-    if (result)
-      paired.add(result.part);
-    return part;
-  };
-  const convertedTool = (source) => {
-    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
-    const output = toolStateContent(sourceState);
-    const { content: _content, ...projectedState } = structuredClone(sourceState);
-    const part = {
-      type: "tool",
-      callID: source.callID ?? source.id,
-      tool: source.tool ?? source.name,
-      state: { ...projectedState, output }
-    };
-    bridges.set(part, { native: source, output });
-    return part;
-  };
-  const callParts = new Map;
-  for (const message of source) {
-    for (const part of message.content) {
-      if (part.type === "tool-call") {
-        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
-      } else if (part.type === "tool") {
-        callParts.set(part, convertedTool(part));
-      }
-    }
-  }
-  const messages = [];
-  for (const message of source) {
-    const parts = [];
-    for (const content of message.content) {
-      if (paired.has(content))
-        continue;
-      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
-      if (message.id && admittedIDs.has(message.id))
-        part.synthetic = true;
-      parts.push(part);
-    }
-    if (!parts.length && message.content.length)
-      continue;
-    const byCallID = new Map;
-    for (const part of parts) {
-      const bridge = bridges.get(part);
-      if (bridge && typeof part.callID === "string")
-        byCallID.set(part.callID, bridge);
-    }
-    if (typeof message.id === "string") {
-      bridgesByMessageID.set(message.id, byCallID);
-      originalsByID.set(message.id, message);
+function registerV2DreamScheduleTimer(args) {
+  const { config, directory, dreamer, executor } = args;
+  const gitCommitIndexing = config.memory.git_commit_indexing;
+  let disposed = false;
+  const registration = startDreamScheduleTimer({
+    directory,
+    projectIdentity: args.projectIdentity,
+    harness: "opencode",
+    hiddenCompletionExecutor: executor,
+    findParentSessionId: () => findV2DreamParentSession(args.openReader, directory),
+    openOpenCodeDb: () => null,
+    retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
+    dreamerConfig: dreamer,
+    sampleDreamRun: () => {
+      const current = dreamerRunConfig(config, args.liveConfig());
+      return { dreamerConfig: current.dreamer ?? dreamer, mural: current.mural };
+    },
+    validateTaskModels: (tasks) => selectRunnableDreamTasks({ tasks, toolsSupported: executor.capabilities.tools }).runnable,
+    language: config.language,
+    mural: config.mural,
+    memoryEnabled: config.memory.enabled === true,
+    memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
+    retinaHandoff: config.smart_notes.retina_handoff,
+    smartNotesEnabled: config.smart_notes.enabled,
+    embeddingConfig: config.embedding,
+    gitCommitIndexing: gitCommitIndexing?.enabled ? {
+      enabled: true,
+      since_days: gitCommitIndexing.since_days,
+      max_commits: gitCommitIndexing.max_commits
+    } : undefined,
+    ensureRegistered: ensureProjectRegisteredFromOpenCodeDirectory
+  }).catch((error) => {
+    log2(`[magic-context] v2 dream timer registration failed (continuing without it): ${error}`);
+    return;
+  });
+  return {
+    async dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      const stop = await registration;
+      stop?.();
     }
-    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);
+  };
+}
+
+// src/v2/hooks/dream-trigger.ts
+async function sessionInThisLocation(context, sessionID) {
+  let location;
+  try {
+    location = (await context.session.get({ sessionID })).location;
+  } catch {
+    return false;
   }
-  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;
+  return location?.directory === context.location.directory && (location.workspaceID ?? "") === (context.location.workspaceID ?? "");
+}
+function startDreamTrigger(context, args) {
+  const controller = new AbortController;
+  const done = (async () => {
+    try {
+      for await (const value of context.event.subscribe({ signal: controller.signal })) {
+        if (controller.signal.aborted)
+          break;
+        const event = value;
+        if (event.type !== "session.execution.succeeded" || !event.data?.sessionID)
+          continue;
+        if (!await sessionInThisLocation(context, event.data.sessionID))
+          continue;
+        const db = openCurrentDatabase();
+        if (!db)
+          continue;
+        try {
+          const reader = args.openReader?.() ?? new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
+          try {
+            const activity = reader.rootSessionActivity([event.data.sessionID]).get(event.data.sessionID);
+            if (activity !== undefined)
+              advanceSessionActivity(db, event.data.sessionID, activity);
+          } finally {
+            reader.close();
           }
-          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
-                    }
-                  }
-                ]
-              });
-            }
+          const sampled = args.sample?.();
+          if ((sampled?.config ?? args.config).disable === true)
             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);
+          const { runnable } = selectRunnableDreamTasks({
+            tasks: buildDreamTaskRuntimeConfigs2(sampled?.config ?? args.config, "opencode", args.language, args.smartNotesEnabled),
+            toolsSupported: args.executor.capabilities.tools === true
+          });
+          await runDueTasksForProject({
+            db,
+            projectIdentity: args.projectIdentity(),
+            projectMemoryEnabled: args.projectMemoryEnabled,
+            tasks: runnable,
+            executor: createDreamTaskExecutor({
+              hiddenCompletionExecutor: args.executor,
+              parentSessionId: event.data.sessionID,
+              sessionDirectory: context.location.directory,
+              openOpenCodeDb: () => null,
+              retrospectiveRawProvider: (db) => new V2RetrospectiveRawProvider(db),
+              language: args.language,
+              mural: sampled?.mural ?? args.mural,
+              smartNotesEnabled: args.smartNotesEnabled
+            })
+          });
+        } catch (error) {
+          log2("[magic-context] v2 dream scheduling failed", error);
         }
-        rendered.push(...following);
       }
-      draft.messages.splice(0, draft.messages.length, ...rendered);
+    } catch (error) {
+      if (!controller.signal.aborted)
+        log2("[magic-context] v2 dream event subscription failed", error);
+    }
+  })();
+  return {
+    async dispose() {
+      controller.abort();
+      await done;
     }
   };
 }
@@ -2738,7 +3460,7 @@ async function warmModelLimitCacheFromCatalog(context, options = {}) {
       retryDelayMs: options.retryDelayMs ?? 1000
     });
   } catch (error) {
-    sessionLog("global", `v2 model-limit cache warm failed: ${getErrorMessage(error)}`);
+    sessionLog2("global", `v2 model-limit cache warm failed: ${getErrorMessage(error)}`);
   } finally {
     if (!modelLimitCacheWarm())
       warmStarted = false;
@@ -2899,7 +3621,7 @@ function runV2SessionProjectBackfill(db, openStoreReader, allowHomeProject = fal
     } finally {
       reader.close();
     }
-  }, { leaseKey: `${getHarness()}:session-projects-creation-v2`, allowHomeProject });
+  }, { leaseKey: `${getHarness2()}:session-projects-creation-v2`, allowHomeProject });
 }
 
 // src/v2/hooks/storage-gate.ts
@@ -3223,6 +3945,7 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
     ...createCtxNoteTools({
       ...project,
       dreamerEnabled: isDreamerRunnable(config),
+      smartNotesEnabled: config.smart_notes.enabled,
       ...rustToolBackends ? { rustToolBackends } : {}
     }),
     ...createCtxSearchTools(project),
@@ -3250,7 +3973,7 @@ async function registerTools(context, db, config, rustToolBackends, isInternalCh
           if (refusal)
             return { content: refusal };
           if (name === "ctx_memory" || name === "ctx_note" || name === "ctx_reduce")
-            await withAsyncPrivilegedWriter(db, () => {
+            await withAsyncPrivilegedWriter2(db, () => {
               return;
             });
           const parsedInput = tool.schema.object(definition.args).passthrough().safeParse(input);
@@ -3316,7 +4039,7 @@ function persistV2UsageReading(args) {
   const { db, sessionID, draftModel, reading } = args;
   const currentMeta = getOrCreateSessionMeta(db, sessionID);
   if (reading.completed !== undefined && currentMeta.lastResponseTime > 0 && reading.completed <= currentMeta.lastResponseTime) {
-    sessionLog(sessionID, `v2 usage: skipped stale reading completed=${reading.completed} <= lastResponseTime=${currentMeta.lastResponseTime}`);
+    sessionLog2(sessionID, `v2 usage: skipped stale reading completed=${reading.completed} <= lastResponseTime=${currentMeta.lastResponseTime}`);
     return;
   }
   const draftModelKey = `${draftModel.providerID}/${draftModel.id}`;
@@ -3343,7 +4066,7 @@ function persistV2UsageReading(args) {
   if (responseTime)
     updates.lastResponseTime = responseTime;
   updateSessionMeta(db, sessionID, updates);
-  sessionLog(sessionID, `v2 usage: inputTokens=${reading.inputTokens} contextLimit=${reading.limit} percentage=${percentage} responseModel=${reading.modelKey ?? "legacy"} draftContextLimit=${reading.admissionLimit} pressure=${readingMatchesDraft ? "current" : "stale-model-ignored"}`);
+  sessionLog2(sessionID, `v2 usage: inputTokens=${reading.inputTokens} contextLimit=${reading.limit} percentage=${percentage} responseModel=${reading.modelKey ?? "legacy"} draftContextLimit=${reading.admissionLimit} pressure=${readingMatchesDraft ? "current" : "stale-model-ignored"}`);
   if (readingMatchesDraft) {
     args.contextUsageMap.set(sessionID, {
       usage: { inputTokens: reading.inputTokens, percentage },
@@ -3356,6 +4079,8 @@ function persistV2UsageReading(args) {
 }
 
 // src/v2/hooks/context.ts
+class V2LkgAdmissionReplay extends Error {
+}
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
 function isBlockingV2TransformError(error) {
   return error instanceof EmergencyFailClosedError || error instanceof UnresolvedHistoryBoundaryError || error instanceof UnmanagedOverWindowError || error instanceof DegradedPassRefusalError || isFailClosedBlockingError(error);
@@ -3369,7 +4094,7 @@ function checkHistoryBoundary(db, reader, sessionID) {
       isInHostStore: (messageId) => storeHasSession ? reader.sequenceForId(sessionID, messageId) !== undefined : null
     });
   } catch (error) {
-    sessionLog(sessionID, "history boundary check failed; continuing without repair", error);
+    sessionLog2(sessionID, "history boundary check failed; continuing without repair", error);
     return;
   }
 }
@@ -3382,18 +4107,19 @@ async function cacheV2SessionDirectory(session, sessionID, directories) {
       directories.set(sessionID, directory);
     }
   } catch (error) {
-    sessionLog(sessionID, "v2 session directory lookup failed; using the launch directory:", error);
+    sessionLog2(sessionID, "v2 session directory lookup failed; using the launch directory:", error);
   }
 }
 function refuseBeforeProvider(session, sessionID, arm, cause) {
   const detail = cause instanceof Error ? `${cause.name}: ${cause.message}` : cause === undefined ? "" : String(cause);
-  sessionLog(sessionID, `v2 refusal: interrupting the turn before the provider request arm=${arm}${detail ? ` cause=${JSON.stringify(detail.slice(0, 500))}` : ""}`);
+  sessionLog2(sessionID, `v2 refusal: interrupting the turn before the provider request arm=${arm}${detail ? ` cause=${JSON.stringify(detail.slice(0, 500))}` : ""}`);
   return interruptBeforeProvider(session, sessionID);
 }
 function createHostSeams(context, readAllForConversion, reconciliationSource, liveModels) {
   return {
     hostRawMessages: readAllForConversion,
     hostMessageReconciliationSource: reconciliationSource,
+    hostPrepareRawOrdinals: async () => true,
     hostProtectedTailBoundary: (args) => resolveOpenCodeProtectedTailBoundary({
       ...args,
       cacheNamespace: `opencode2:${args.sessionId}`
@@ -3449,7 +4175,7 @@ function toolResultText2(result) {
 `);
 }
 function reportPreProviderRefusal(sessionID, error) {
-  sessionLog(sessionID, `v2 refusing this turn before the model call: the context could not be read: ${getErrorMessage(error)}`);
+  sessionLog2(sessionID, `v2 refusing this turn before the model call: the context could not be read: ${getErrorMessage(error)}`);
 }
 function catalogModels(listed, draftModel) {
   const rows = Array.isArray(listed) ? listed : listed && typeof listed === "object" && Array.isArray(listed.data) ? listed.data : [];
@@ -3487,7 +4213,7 @@ function removeDreamerOnlyTools(draft) {
   if (draft.tools)
     delete draft.tools.ctx_memory_list;
 }
-function applyV2PromptSurfaceTools(draft, runtime, config) {
+function applyV2PromptSurfaceTools(draft, runtime, config, smartNotesEnabled = true) {
   if (!draft.tools)
     return;
   const modelKey = `${draft.model.providerID}/${draft.model.id}`;
@@ -3496,8 +4222,8 @@ function applyV2PromptSurfaceTools(draft, runtime, config) {
     const tool = draft.tools[id];
     if (!tool)
       continue;
-    tool.description = registration.descriptionFor(id, tool.description);
-    applyJsonSchemaParameterDescriptions(id, tool.input, registration.preset);
+    tool.description = id === "ctx_note" && !smartNotesEnabled ? withoutSmartNoteText(registration.preset === "light" ? CTX_NOTE_LIGHT_DESCRIPTION : CTX_NOTE_DESCRIPTION) : registration.descriptionFor(id, tool.description);
+    applyJsonSchemaParameterDescriptions(id, tool.input, registration.preset, smartNotesEnabled);
   }
 }
 function recordV2ToolDefinitions(draft) {
@@ -3539,13 +4265,13 @@ async function registerContext(context) {
   if (!hasRequiredSessionAPI(context.session) || !nativeRemove) {
     const message = OPENCODE2_SESSION_API_NOTICE;
     console.warn(`[magic-context] v2 host API unavailable: ${message}`);
-    log(`[magic-context] ${message}`);
+    log2(`[magic-context] ${message}`);
     let noticed = false;
     const refuseUnsupportedHost = async (draft) => {
       if (!noticed) {
         noticed = true;
         pushNotification2("toast", { message, variant: "error" }, draft.sessionID);
-        context.session.wait({ sessionID: draft.sessionID }).then(() => deliverSynthetic(context, draft.sessionID, message)).catch((error) => sessionLog(draft.sessionID, "host API notice could not be delivered:", error));
+        context.session.wait({ sessionID: draft.sessionID }).then(() => deliverSynthetic(context, draft.sessionID, message)).catch((error) => sessionLog2(draft.sessionID, "host API notice could not be delivered:", error));
       }
       await refuseBeforeProvider(context.session, draft.sessionID, "unsupported-session-api");
     };
@@ -3557,7 +4283,6 @@ async function registerContext(context) {
     return;
   }
   const liveConfigReader = pluginConfigReader(directory, config);
-  const checkoutClaim = createSubcCheckoutClaimGate("opencode", () => config.subc?.connection_file ?? getDefaultSubcConnectionFile());
   const compactionOff = !isCompactionEnabled(config);
   const conflicts = detectConflicts(directory, {
     compactionEnabled: !compactionOff,
@@ -3568,6 +4293,8 @@ async function registerContext(context) {
     return;
   }
   const folds = new FoldOwner(context.storage);
+  const nativeFoldMemory = !compactionOff && process.env.MC_OC2_INVISIBLE_FOLD === "1" ? nativeFoldCache(() => storage.require()) : undefined;
+  const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader()) : undefined;
   setOutputReserveConfig(config.output_reserve);
   const queriedModels = new Set;
   const rawLimits = new Map;
@@ -3576,13 +4303,13 @@ async function registerContext(context) {
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
     harness: "opencode2",
     directory,
-    warn: (message) => log(`[magic-context] config warning: ${message}`)
+    warn: (message) => log2(`[magic-context] config warning: ${message}`)
   });
   const storage = createV2StorageGate({
     onUnavailable: (reason) => {
       const message = formatFailClosedBlockingMessage(reason);
       console.warn(`[magic-context] v2 storage unavailable: ${message}`);
-      log(`[magic-context] v2 storage unavailable: ${message}`);
+      log2(`[magic-context] v2 storage unavailable: ${message}`);
     }
   });
   let db = await probeV2StorageAtBoot(storage);
@@ -3592,14 +4319,14 @@ async function registerContext(context) {
     if (legacyCleanupStarted)
       return;
     legacyCleanupStarted = true;
-    await cleanupLegacyHiddenChildren(database, nativeRemove, log);
+    await cleanupLegacyHiddenChildren(database, nativeRemove, log2);
   };
   if (db && isDatabasePersisted(db))
     await cleanupLegacyOnce(db);
   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)));
+    withoutSqliteTransformPass2(() => Promise.resolve().then(() => context.session.wait({ sessionID })).then(() => deliverSynthetic(context, sessionID, text)).catch((error) => sessionLog2(sessionID, `v2 storage ${what} notice could not be delivered:`, error)));
   };
   const noticeStorageRefusal = (sessionID, reason) => {
     const message = formatStorageRefusalNotice(reason);
@@ -3651,7 +4378,7 @@ async function registerContext(context) {
     const refusal = hiddenToolCallRefusal(draft, hiddenChildHook);
     if (refusal === undefined)
       return;
-    sessionLog(draft.sessionID, "hidden child tool call refused", {
+    sessionLog2(draft.sessionID, "hidden child tool call refused", {
       tool: draft.tool,
       agent: draft.agent ?? null
     });
@@ -3704,6 +4431,7 @@ async function registerContext(context) {
     const cappedExecutor = withLiveDreamerOutputCap(executor, config, () => liveConfigReader.poll().effective);
     const trigger = startDreamTrigger(context, {
       config: dreamerAtBoot,
+      smartNotesEnabled: config.smart_notes.enabled,
       sample: () => {
         const current = dreamerRunConfig(config, liveConfigReader.poll().effective);
         return { config: current.dreamer ?? dreamerAtBoot, mural: current.mural };
@@ -3739,7 +4467,7 @@ async function registerContext(context) {
       dreamTrigger ??= startDreamer(hiddenCompletionExecutor);
       return true;
     } catch (error) {
-      log("[magic-context] v2 historian and dreamer could not start after recovery:", error);
+      log2("[magic-context] v2 historian and dreamer could not start after recovery:", error);
       return false;
     }
   })();
@@ -3798,7 +4526,7 @@ async function registerContext(context) {
       const baseline = channel1.get(draft.sessionID);
       await deliverPendingChannel2(context, db, draft.sessionID, baseline);
     } catch (error) {
-      log("[magic-context] v2 Channel 2 delivery deferred", error);
+      log2("[magic-context] v2 Channel 2 delivery deferred", error);
     }
   });
   const pagedRead = createV2RawMessageReader(openStoreReader);
@@ -3816,7 +4544,7 @@ async function registerContext(context) {
         } finally {
           reader.close();
         }
-      })).catch((error) => log("[session-project-backfill] OpenCode 2 backfill failed:", error));
+      })).catch((error) => log2("[session-project-backfill] OpenCode 2 backfill failed:", error));
     });
   }
   const readAllForConversion = (sessionID) => readAllV2RawMessagesForConversion(openStoreReader, sessionID);
@@ -3861,17 +4589,17 @@ async function registerContext(context) {
       forkSeedSettled.add(sessionID);
       if (outcome.kind === "seeded") {
         const { result } = outcome;
-        sessionLog(sessionID, `v2 fork inheritance: seeded from ${outcome.parentSessionID} through the fork boundary; paired rows=${outcome.pairedRows} compartments=${result.compartmentsCopied} tags=${result.tagsCopied} pending_ops=${result.pendingOpsCopied} facts=${result.factsCopied} notes=${result.notesCopied}`);
+        sessionLog2(sessionID, `v2 fork inheritance: seeded from ${outcome.parentSessionID} through the fork boundary; paired rows=${outcome.pairedRows} compartments=${result.compartmentsCopied} tags=${result.tagsCopied} pending_ops=${result.pendingOpsCopied} facts=${result.factsCopied} notes=${result.notesCopied}`);
       } else if (outcome.kind === "parent-missing") {
-        sessionLog(sessionID, `v2 fork inheritance: fork of ${outcome.parentSessionID} starts without inherited state (${outcome.reason})`);
+        sessionLog2(sessionID, `v2 fork inheritance: fork of ${outcome.parentSessionID} starts without inherited state (${outcome.reason})`);
       } else if (outcome.kind === "destination-not-empty") {
-        sessionLog(sessionID, `v2 fork inheritance: fork of ${outcome.parentSessionID} already has state; not copied again`);
+        sessionLog2(sessionID, `v2 fork inheritance: fork of ${outcome.parentSessionID} already has state; not copied again`);
       }
     } catch (error) {
-      if (isTransientSqliteError(error))
+      if (isTransientSqliteError2(error))
         throw error;
       forkSeedSettled.add(sessionID);
-      sessionLog(sessionID, "v2 fork inheritance failed; continuing without it:", error);
+      sessionLog2(sessionID, "v2 fork inheritance failed; continuing without it:", error);
     } finally {
       reader?.close();
     }
@@ -3957,6 +4685,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.MC_OC2_HOST_FOLD_ROWS ?? 1000),
+    log: sessionLog2
+  }) : undefined;
   const usageController = new AbortController;
   const usageDone = (async () => {
     try {
@@ -3967,10 +4703,28 @@ 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)
             hiddenSessionErrors.set(sessionID, error);
+          if (error !== undefined && db && !compactionOff) {
+            const model = liveModels.get(sessionID);
+            try {
+              armLatestThinkingRecoveryFromError({
+                db,
+                sessionId: sessionID,
+                error,
+                providerID: model?.providerID,
+                modelID: model?.modelID
+              });
+            } catch (armError) {
+              log2("[magic-context] v2 latest-thinking recovery arm failed", armError);
+            }
+          }
           continue;
         }
         if (event.type === "session.deleted") {
@@ -3992,6 +4746,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);
@@ -4001,15 +4756,18 @@ 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)
-        log("[magic-context] v2 usage subscription failed", error);
+        log2("[magic-context] v2 usage subscription failed", error);
     }
   })();
   const materialize = (draft) => {
@@ -4040,19 +4798,41 @@ 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);
       const moduleBaseline = rustModeModuleClient ? servedModuleM0Text(draft.sessionID) : undefined;
       const source = !rustModeModuleClient ? "typescript" : moduleBaseline === null ? "typescript_fallback" : "module";
+      if (nativeFoldReplay) {
+        try {
+          if (await nativeFoldReplay.canReplay(draft.sessionID, reader)) {
+            const state = getOrCreateSessionMeta(storage.require(), draft.sessionID);
+            const summary = moduleBaseline ?? 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);
+          sessionLog2(draft.sessionID, `v2 host fold: legacy compaction reason=${JSON.stringify(String(error))}`);
+        }
+      }
       const fold = await folds.supply({
         sessionID: draft.sessionID,
         watermark,
         runningCut: running?.seq,
         materialize: () => moduleBaseline ?? materialize(draft)
       });
-      sessionLog(draft.sessionID, `v2 compaction hook: fired answered=true source=${source}`);
+      sessionLog2(draft.sessionID, `v2 compaction hook: fired answered=true source=${source}`);
       draft.result = { summary: fold.submitted };
     } catch (cause) {
       await refuseBeforeProvider(context.session, draft.sessionID, "compaction-fold", cause);
@@ -4072,17 +4852,11 @@ async function registerContext(context) {
     removeDreamerOnlyTools(draft);
     if (deletedSessions.has(draft.sessionID))
       return;
-    const claimRefusal = await checkoutClaim.refusal(draft.sessionID, directory);
-    if (claimRefusal) {
-      pushNotification2("toast", { message: claimRefusal.message, variant: "error" }, draft.sessionID);
-      await refuseBeforeProvider(context.session, draft.sessionID, "checkout-claim-held-elsewhere", claimRefusal);
-      throw new V2ContextRefusal(claimRefusal.message, { cause: claimRefusal });
-    }
     const systemAtEntry = structuredClone(draft.system);
     const slotAtEntry = getSlot(draft.sessionID);
     const restoreLkgSystem = () => {
       if (!lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), systemAtEntry, draft.system)) {
-        sessionLog(draft.sessionID, "lkg_system_state_mismatch");
+        sessionLog2(draft.sessionID, "lkg_system_state_mismatch");
         throw new Error("LKG system identity is unavailable or changed");
       }
     };
@@ -4099,15 +4873,68 @@ async function registerContext(context) {
     });
     variants.set(draft.sessionID, draft.model.variant);
     if (!modelLimitCacheWarm())
-      withoutSqliteTransformPass(() => warmModelLimitCacheFromCatalog(context));
+      withoutSqliteTransformPass2(() => warmModelLimitCacheFromCatalog(context));
     agents.set(draft.sessionID, draft.agent);
-    applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface);
+    applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface, config.smart_notes.enabled);
+    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, () => {
+        await withAsyncPrivilegedWriter2(admissionDb, () => {
           return;
+        }, {
+          beforeRetry: (error) => {
+            const mapped = adaptPayload(draft);
+            if (tryMessagesTransformLkgReplay({
+              output: mapped,
+              sessionId: draft.sessionID,
+              error,
+              agent: draft.agent,
+              rust: transform?.getRustReplayParticipant() ?? undefined,
+              replayFits,
+              onLkgReplay: restoreLkgSystem
+            })) {
+              mapped.commit();
+              throw new V2LkgAdmissionReplay;
+            }
+          }
         });
       if (admissionDb)
         hideSubagentTools(draft, admissionDb);
@@ -4128,7 +4955,7 @@ async function registerContext(context) {
         storageRecoveryAnnounced = true;
         const recovered = await recoverHiddenWork(db);
         const message = formatStorageRecoveryNotice(recovered);
-        log(`[magic-context] v2 storage recovered: ${message}`);
+        log2(`[magic-context] v2 storage recovered: ${message}`);
         pushNotification2("toast", { message, variant: "info" }, draft.sessionID);
         storeStorageNotice(draft.sessionID, message, "recovery");
       }
@@ -4143,11 +4970,12 @@ async function registerContext(context) {
           readMessagePages: (sessionID) => readV2RawMessagePagesForConversion(openStoreReader, sessionID)
         });
       } catch (error) {
-        sessionLog(draft.sessionID, "store projection rebase failed before system prompt (retrying in transform):", error);
+        sessionLog2(draft.sessionID, "store projection rebase failed before system prompt (retrying in transform):", error);
       }
       systemPrompt ??= createSystemPromptHashHandler({
         db,
         dreamerEnabled: config.dreamer !== undefined && !config.dreamer.disable,
+        smartNotesEnabled: config.smart_notes.enabled,
         memoryEnabled: config.memory.enabled && !!resolveProjectIdentityForSession(directory, config.allow_home_project),
         language: config.language,
         promptSurface: config.prompt_surface,
@@ -4210,7 +5038,7 @@ async function registerContext(context) {
         pendingMaterializationSessions,
         lastHeuristicsTurnId,
         variantBySession: variants,
-        clearReasoningAge: config.clear_reasoning_age,
+        keepReasoningTokens: config.keep_reasoning_tokens,
         directory,
         sessionDirectoryBySession: sessionDirectories,
         projectPath: directory,
@@ -4262,6 +5090,8 @@ async function registerContext(context) {
             admitted.add(message.id);
         }
         const cut = reader.latestCompaction(draft.sessionID);
+        if (nativeFoldReplay)
+          await nativeFoldReplay.observeSource(draft.sessionID, reader);
         const boundaryRepair = !rustModeModuleClient && db && !compactionOff ? checkHistoryBoundary(db, reader, draft.sessionID) : undefined;
         if (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset") {
           historyRefreshSessions.add(draft.sessionID);
@@ -4271,14 +5101,35 @@ 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: !rustModeModuleClient });
+          } catch (error) {
+            nativeFoldReplay.invalidate(draft.sessionID, true);
+            sessionLog2(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,
             summary: cut.data.summary ?? "",
             rendered: incoming,
             onHard: (reason) => {
-              sessionLog(draft.sessionID, `HARD reason=${reason}`);
+              sessionLog2(draft.sessionID, `HARD reason=${reason}`);
               materialize(draft);
               pendingMaterializationSessions.add(draft.sessionID);
             }
@@ -4291,11 +5142,11 @@ async function registerContext(context) {
           const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
           const boundary = (moduleBoundarySeq !== undefined ? moduleBoundarySeq - 1 : undefined) ?? servedBoundary?.seq ?? reader.sequenceForId(draft.sessionID, boundaryID) ?? (reader.earliestSequence(draft.sessionID) ?? 0) - 1;
           if (moduleBoundarySeq !== undefined)
-            sessionLog(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
+            sessionLog2(draft.sessionID, `v2 restore: from the module boundary ${moduleBoundaryID} to the host checkpoint`);
           const present = new Set(draft.messages.map((message) => message.id));
           const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
             asset: hostMediaAsset,
-            unavailable: (detail) => sessionLog(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
+            unavailable: (detail) => sessionLog2(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
           } : undefined));
           draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
         }
@@ -4305,13 +5156,22 @@ async function registerContext(context) {
       if (rustModeModuleClient && db) {
         const dropped = trimToRecordedBoundary(db, draft.sessionID, draft.messages);
         if (dropped > 0)
-          sessionLog(draft.sessionID, `v2 boundary trim: dropped ${dropped} messages before the module boundary`);
+          sessionLog2(draft.sessionID, `v2 boundary trim: dropped ${dropped} messages before the module boundary`);
+      }
+      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 createMessagesTransformHandler({
         magicContext: { "experimental.chat.messages.transform": transform },
         compactionOff,
+        replayFits,
         onLkgReplay: restoreLkgSystem,
         rustReplayParticipant: () => transform?.getRustReplayParticipant() ?? null
       })({}, mapped);
@@ -4337,18 +5197,29 @@ ${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);
+          sessionLog2(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);
       }
     } catch (error) {
+      if (error instanceof V2LkgAdmissionReplay)
+        return;
       if (error instanceof V2ContextRefusal)
         throw error;
-      if (!compactionOff && (isTransientSqliteError(error) || error instanceof StorageBusyRefusalError)) {
-        if (isTransientSqliteError(error)) {
+      if (!compactionOff && (isTransientSqliteError2(error) || error instanceof StorageBusyRefusalError)) {
+        if (isTransientSqliteError2(error)) {
           const mapped = adaptPayload(draft);
           try {
             await createMessagesTransformHandler({
+              replayFits,
               onLkgReplay: restoreLkgSystem,
               rustReplayParticipant: () => transform?.getRustReplayParticipant() ?? null,
               magicContext: {
@@ -4381,16 +5252,16 @@ ${baseline}
             cause: managedError
           });
         }
-        log("[magic-context] compaction-off: fail-closed inert, passing through", error);
+        log2("[magic-context] compaction-off: fail-closed inert, passing through", error);
       } else if (postFold) {
         await refuseBeforeProvider(context.session, draft.sessionID, "post-fold-restore", error);
         throw new V2ContextRefusal("Magic Context could not restore the unarchived host history.", { cause: error });
       } else {
-        log("[magic-context] v2 context unavailable", error);
+        log2("[magic-context] v2 context unavailable", error);
       }
     }
   };
-  await context.session.hook("context", (draft) => withSqliteTransformPass(async () => {
+  await context.session.hook("context", (draft) => withSqliteTransformPass2(async () => {
     const anchor = draft.messages.at(-1)?.id;
     await runManagedContext(draft);
     if (!compactionOff && draft.messages.some((message) => message.id === HEAD_IDS[0] || message.content.some((part) => typeof part.text === "string" && part.text.includes("<session-history>"))))
@@ -4400,7 +5271,7 @@ ${baseline}
     if (!compactionOff && !deletedSessions.has(draft.sessionID))
       generateReplay.apply(draft);
   });
-  withoutSqliteTransformPass(() => warmModelLimitCacheFromCatalog(context));
+  withoutSqliteTransformPass2(() => warmModelLimitCacheFromCatalog(context));
   const rpcLiveSessionState = createV2RpcLiveSessionState({
     liveModelBySession: liveModels,
     variantBySession: variants,
@@ -4461,6 +5332,7 @@ ${baseline}
     runManualDreamNow({
       db: runDb,
       dreamer: manualDreamer,
+      smartNotesEnabled: config.smart_notes.enabled,
       projectIdentity: resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
       directory,
       language: config.language,
@@ -4499,7 +5371,7 @@ ${baseline}
   setTimeout(() => {
     if (rpcStopped)
       return;
-    rpcServer.start().catch((error) => log("[magic-context] v2 RPC server failed to start", error));
+    rpcServer.start().catch((error) => log2("[magic-context] v2 RPC server failed to start", error));
   }, 0);
   return {
     async dispose() {