@cortexkit/opencode-magic-context 0.45.0 → 0.46.0

package/dist/context-8dkpszy5.js

@@ -0,0 +1,4483 @@
+import {
+  getMagicContextBuiltinCommands,
+  isDreamerRunnable,
+  isCompactionEnabled,
+  getProtectedTokensTierOverrides,
+  loadPluginConfigDetailed,
+  BoundedSessionMap,
+  historianRunConfig,
+  dreamerRunConfig,
+  pluginConfigReader,
+  withLiveDreamerOutputCap,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  advanceSessionActivity,
+  backfillSessionActivity,
+  invalidateAutoEmbedSession,
+  deleteChunkEmbedBackoffForSession,
+  acquireCompartmentLease,
+  releaseCompartmentLeaseBestEffort,
+  isCompartmentLeaseHeld,
+  queueM0Mutation,
+  clearCachedM0M1,
+  getCompartments,
+  getUncoveredCompartmentEndsThrough,
+  getProtectionWindowForSession,
+  getChannel2NudgeState,
+  claimChannel2NudgeState,
+  casChannel2NudgeClaim,
+  getOverflowState,
+  recordOverflowDetected,
+  recordDetectedContextLimit,
+  getPersistedCompactionMarkerState,
+  setPersistedCompactionMarkerState,
+  getObservedEpochFloor,
+  providerResponseFailed,
+  isSuccessfulProviderCompletion,
+  lkgProviderInputTotal,
+  beginV2LkgRequest,
+  noteLkgProviderResponse,
+  getSlot,
+  copySessionStateForClone,
+  gaDatabasePath,
+  RAW_MESSAGE_TYPES,
+  V2StoreReaderPool,
+  V2StoreReader,
+  getOrCreateSessionMeta,
+  updateSessionMeta,
+  markSessionCleanupPending,
+  clearSession,
+  HiddenCompletionRefusal,
+  HIDDEN_HISTORIAN_AGENT,
+  HIDDEN_DREAMER_AGENT,
+  HIDDEN_CURATE_AGENT,
+  hiddenAgentFor,
+  hiddenToolLoop,
+  registerHiddenChildAgents,
+  HiddenAgentStepLimit,
+  HiddenChildHook,
+  parseProviderModel,
+  toModelEntry,
+  ACTIVE_TOOL_IDS,
+  createPromptSurfaceRuntime,
+  runTokenLog,
+  rebaseSessionCoordinatesAsync,
+  clearInjectionCache,
+  materializeM0,
+  resetPrefixTrimFallbackState,
+  resolveOpenCodeProtectedTailBoundary,
+  getActiveCompartmentRun
+} from "./index-p821bjdb.js";
+import"./index-sd3egckz.js";
+import {
+  getHarness,
+  getDataDir,
+  getMagicContextStorageDir
+} from "./index-q6hef7fh.js";
+import {
+  log,
+  sessionLog
+} from "./index-hybnrwq0.js";
+import {
+  isSaneLimit,
+  setOutputReserveConfig,
+  resolveLimit,
+  refreshModelLimitsFromApi,
+  getModelsDevCacheState,
+  deriveHistorianChunkTokens2,
+  resolveKnownHistorianContextLimit2,
+  resolveHistorianContextLimit2
+} from "./index-0d3g3461.js";
+import"./index-yasgb8ej.js";
+import"./index-q4yp4b52.js";
+import {
+  CANONICAL_DREAM_TASKS,
+  DREAM_TASK_CAPABILITIES,
+  formatUnsupportedDreamTasks,
+  isCanonicalDreamTask,
+  buildDreamTaskRuntimeConfigs2,
+  userMemoryCollectionEnabled2
+} from "./index-mc22ayvf.js";
+import {
+  resolveHistorianModel2
+} from "./index-sfpzqvdz.js";
+import {
+  formatFailClosedBlockingMessage,
+  formatFailClosedBlockingSummary,
+  createFailClosedBlockingError,
+  isFailClosedBlockingError,
+  setHomeProjectPermission,
+  resolveProjectIdentityForSession,
+  scheduleAfterBootQuiet,
+  startBootDeadline,
+  BOOT_SQLITE_BUSY_TIMEOUT_MS,
+  openCurrentDatabase,
+  openDatabaseAsync,
+  isDatabasePersisted,
+  getDatabasePersistenceError
+} from "./index-r5hmbx3t.js";
+import {
+  isDroppedToolOutput,
+  evaluateChannel2,
+  reclaimableToolOutputCount,
+  buildChannel2Reminder,
+  markHostUnservedRow,
+  DreamTokenBudgetExceeded,
+  createDreamTokenBudget,
+  recordToolParameters,
+  createDroppedInputGuard,
+  assertExecutableToolInput,
+  detectOverflow,
+  hasRawMessageProvider2,
+  setBoundedRawMessageProvider2,
+  cleanUserText2,
+  readRawSessionMessageIdOrdinalsForRange2,
+  readRawSessionMessageOrdinalById2
+} from "./index-3h0ybwah.js";
+import {
+  hasMeaningfulUserText2,
+  preloadTokenizer,
+  estimateTokens
+} from "./index-5eqk6z3s.js";
+import {
+  withSqliteTransformPass,
+  withoutSqliteTransformPass,
+  isTransientSqliteError,
+  withAsyncPrivilegedWriter
+} from "./index-fg34g6a5.js";
+import {
+  getCurrentToolSetHash,
+  recordToolDefinition
+} from "./index-5gq3b2ya.js";
+import"./index-1zx87sdm.js";
+import"./index-b35pxds2.js";
+import"./index-majxda46.js";
+import {
+  createSubcCheckoutClaimGate,
+  runSessionProjectBackfill,
+  createLiveSessionState,
+  getDefaultSubcConnectionFile,
+  RETROSPECTIVE_MAX_USER_MESSAGE_CHARS,
+  RETROSPECTIVE_MESSAGE_TRUNCATION_MARKER,
+  createDreamTaskExecutor,
+  runManualDream,
+  runDueTasksForProject,
+  startDreamScheduleTimer,
+  ensureProjectRegisteredFromOpenCodeDirectory,
+  resolveContextLimit,
+  resolveModelKey,
+  createScheduler,
+  describeStorageUnavailability,
+  getSessionErrorInfo,
+  summarizeManualDream,
+  createChatMessageHook,
+  createToolExecuteAfterHook,
+  recordHiddenVariantWarning,
+  registerRpcHandlers,
+  STORAGE_BUSY_MESSAGE,
+  StorageBusyRefusalError,
+  UnmanagedOverWindowError,
+  UnresolvedHistoryBoundaryError,
+  createTransform,
+  createSubcModuleClient,
+  createModuleToolBackends,
+  createRustRefusalRecovery,
+  createSystemPromptHashHandler,
+  createMessagesTransformHandler,
+  subagentToolRefusal,
+  hideSubagentTools,
+  createCtxExpandTools,
+  createCtxMemoryTools,
+  createCtxMemoryListTools,
+  createCtxNoteTools,
+  createCtxReduceTools,
+  createCtxSearchTools,
+  applyJsonSchemaParameterDescriptions,
+  MagicContextRpcServer
+} from "./index-qr6r7akd.js";
+import {
+  createTagger,
+  setCtxReduceRegisteredGlobally,
+  resolveCtxReduceAvailabilityFromMessages,
+  DegradedPassRefusalError,
+  EmergencyFailClosedError,
+  isSyntheticHeadMessage2
+} from "./index-k4404na5.js";
+import"./index-7qw742ev.js";
+import {
+  pushNotification2,
+  isTuiConnected2
+} from "./index-x8a7jmkh.js";
+import"./index-fzbvakh0.js";
+import"./index-j7fvnjye.js";
+import"./index-k5bdx1bx.js";
+import {
+  detectConflicts
+} from "./index-8da2zjhz.js";
+import"./index-fmsr7v69.js";
+import {
+  getErrorMessage
+} from "./index-y8v6yerm.js";
+import"./index-sj29b3z2.js";
+
+// src/hooks/magic-context/history-boundary-repair.ts
+function readBaseline(db, sessionId) {
+  const row = db.prepare("SELECT cached_m0_bytes IS NOT NULL AS hasM0, cached_m0_last_baseline_end_message_id AS boundary FROM session_meta WHERE session_id = ?").get(sessionId);
+  return {
+    hasCachedM0: row?.hasM0 === 1,
+    boundary: row?.boundary && row.boundary.length > 0 ? row.boundary : null
+  };
+}
+function findAnchor(compartments, latestIndex, isInHostStore) {
+  for (let index = latestIndex - 1;index >= 0; index -= 1) {
+    const candidate = compartments[index];
+    const endId = candidate?.endMessageId;
+    if (!candidate || typeof endId !== "string" || endId.length === 0)
+      continue;
+    const present = isInHostStore(endId);
+    if (present === null)
+      return "unknown";
+    if (present)
+      return candidate;
+  }
+  return null;
+}
+function forgetCachedPrefix(sessionId) {
+  clearInjectionCache(sessionId);
+  resetPrefixTrimFallbackState(sessionId);
+}
+function dropCompartmentsAfter(db, sessionId, anchor, holderId) {
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    if (!isCompartmentLeaseHeld(db, sessionId, holderId)) {
+      db.exec("ROLLBACK");
+      finished = true;
+      return null;
+    }
+    const dropped = db.prepare("SELECT id, sequence FROM compartments WHERE session_id = ? AND sequence > ? ORDER BY sequence").all(sessionId, anchor.sequence);
+    const deleteEmbeddings = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE compartment_id = ?");
+    for (const row of dropped)
+      deleteEmbeddings.run(row.id);
+    db.prepare("DELETE FROM compartments WHERE session_id = ? AND sequence > ?").run(sessionId, anchor.sequence);
+    db.prepare("DELETE FROM compression_depth WHERE session_id = ? AND message_ordinal > ?").run(sessionId, anchor.endMessage);
+    deleteChunkEmbedBackoffForSession(db, sessionId);
+    queueM0Mutation(db, { sessionId, mutationType: "recomp_boundary_change" });
+    clearCachedM0M1(db, sessionId);
+    db.exec("COMMIT");
+    finished = true;
+    return dropped.map((row) => row.sequence);
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+function repairMissingHistoryBoundary(args) {
+  const { db, sessionId, isInHostStore } = args;
+  const compartments = getCompartments(db, sessionId);
+  let latestIndex = compartments.length - 1;
+  while (latestIndex >= 0 && !compartments[latestIndex]?.endMessageId)
+    latestIndex -= 1;
+  if (latestIndex < 0)
+    return { kind: "intact" };
+  const latestEnd = compartments[latestIndex].endMessageId;
+  const latestPresent = isInHostStore(latestEnd);
+  if (latestPresent === null)
+    return { kind: "unknown" };
+  if (!latestPresent) {
+    const missing = latestEnd;
+    const problem = `newest compartment end ${latestEnd} is not in the host store`;
+    const anchor = findAnchor(compartments, latestIndex, isInHostStore);
+    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`);
+      return { kind: "unresolved", reason: "no-anchor", missingEndMessageId: missing };
+    }
+    if (getActiveCompartmentRun(sessionId) !== undefined) {
+      return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
+    }
+    const holderId = crypto.randomUUID();
+    if (!acquireCompartmentLease(db, sessionId, holderId)) {
+      return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
+    }
+    let dropped;
+    try {
+      dropped = dropCompartmentsAfter(db, sessionId, anchor, holderId);
+    } finally {
+      releaseCompartmentLeaseBestEffort(db, sessionId, holderId);
+    }
+    if (dropped === null) {
+      return { kind: "unresolved", reason: "busy", missingEndMessageId: missing };
+    }
+    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`);
+    return {
+      kind: "repaired",
+      missingEndMessageId: missing,
+      anchorEndMessageId: anchor.endMessageId,
+      droppedSequences: dropped
+    };
+  }
+  const baseline = readBaseline(db, sessionId);
+  if (!baseline.hasCachedM0 || baseline.boundary === null || baseline.boundary === latestEnd) {
+    return { kind: "intact" };
+  }
+  if (isInHostStore(baseline.boundary) !== false)
+    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}`);
+  return {
+    kind: "baseline-reset",
+    anchorEndMessageId: latestEnd,
+    staleBaselineId: baseline.boundary
+  };
+}
+
+// src/hooks/magic-context/rust-served-m0.ts
+function servedModuleM0Text(sessionId, readSlot = getSlot) {
+  const slot = readSlot(sessionId);
+  if (!slot)
+    return null;
+  let prefix;
+  try {
+    prefix = JSON.parse(slot.jsonPrefix);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(prefix) || prefix.length === 0)
+    return null;
+  const head = prefix[0];
+  if (!head || typeof head !== "object" || !head.info || !Array.isArray(head.parts))
+    return null;
+  if (!isSyntheticHeadMessage2(head))
+    return null;
+  const text = head.parts.find((part) => part.type === "text");
+  return typeof text?.text === "string" ? text.text : null;
+}
+
+// src/v2/fold/markers.ts
+var v2CompactionMarkerStrategy = {
+  setPending: () => {},
+  publish: () => false,
+  applyDeferred: () => ({ kind: "already-current" }),
+  reconcile: () => false
+};
+
+// src/v2/fold/boundary.ts
+function createV2RustCompactionMarkerStrategy(findBoundaryUserMessage) {
+  return {
+    ...v2CompactionMarkerStrategy,
+    applyDeferred: (db, sessionId, pending) => {
+      const existing = getPersistedCompactionMarkerState(db, sessionId);
+      if (existing && existing.boundaryOrdinal >= pending.ordinal) {
+        return { kind: "already-current" };
+      }
+      let boundary = null;
+      try {
+        boundary = findBoundaryUserMessage(sessionId, pending.endMessageId);
+      } catch (error) {
+        return {
+          kind: "retryable-failure",
+          cut: "definitely-no-cut",
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+      if (!boundary) {
+        return {
+          kind: "retryable-failure",
+          cut: "definitely-no-cut",
+          error: new Error(`no user boundary found at or before endMessageId ${pending.endMessageId} (ordinal ${pending.ordinal}); preserving existing boundary`)
+        };
+      }
+      const state = {
+        boundaryMessageId: boundary.id,
+        summaryMessageId: "",
+        compactionPartId: "",
+        summaryPartId: "",
+        boundaryOrdinal: pending.ordinal,
+        targetEndMessageId: pending.endMessageId
+      };
+      setPersistedCompactionMarkerState(db, sessionId, state);
+      sessionLog(sessionId, `v2 boundary recorded at ordinal ${pending.ordinal}, boundary message ${boundary.id}`);
+      return { kind: "applied", markerOrdinal: pending.ordinal };
+    }
+  };
+}
+function trimToRecordedBoundary(db, sessionId, messages) {
+  const marker = getPersistedCompactionMarkerState(db, sessionId);
+  const boundaryId = marker?.boundaryMessageId;
+  if (!boundaryId)
+    return 0;
+  const start = messages.findIndex((message) => message.id === boundaryId);
+  if (start <= 0)
+    return 0;
+  const uncovered = new Set(getUncoveredCompartmentEndsThrough(db, sessionId).map((end) => end.endMessageId));
+  let partialIndex = messages.findIndex((message) => message.id !== undefined && uncovered.has(message.id));
+  const ranges = db.prepare("SELECT start_message AS start, end_message AS end FROM compartments WHERE session_id=? ORDER BY start_message, end_message").all(sessionId);
+  const coveredRanges = [];
+  for (const range of ranges) {
+    if (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start)
+      continue;
+    const previous = coveredRanges.at(-1);
+    if (previous && range.start <= previous.end + 1)
+      previous.end = Math.max(previous.end, range.end);
+    else
+      coveredRanges.push({ ...range });
+  }
+  const covers = (ordinal) => {
+    if (ordinal === undefined || !Number.isSafeInteger(ordinal))
+      return false;
+    let low = 0, high = coveredRanges.length - 1;
+    while (low <= high) {
+      const middle = low + high >>> 1;
+      const range = coveredRanges[middle];
+      if (!range)
+        return false;
+      if (ordinal < range.start)
+        high = middle - 1;
+      else if (ordinal > range.end)
+        low = middle + 1;
+      else
+        return true;
+    }
+    return false;
+  };
+  let ordinals;
+  const prefix = messages.slice(0, start);
+  if (!prefix.every((message) => Number.isSafeInteger(message.ordinal) && (message.ordinal ?? -1) >= 1)) {
+    if (!hasRawMessageProvider2(sessionId))
+      return 0;
+    try {
+      const cutOrdinal = readRawSessionMessageOrdinalById2(sessionId, boundaryId);
+      if (cutOrdinal === null || cutOrdinal <= 1)
+        return 0;
+      ordinals = readRawSessionMessageIdOrdinalsForRange2(sessionId, 1, cutOrdinal - 1);
+    } catch {
+      return 0;
+    }
+  }
+  for (let index = 0;index < start; index++) {
+    const message = messages[index];
+    if (!message)
+      return 0;
+    const ordinal = ordinals ? message.id ? ordinals.get(message.id) : undefined : message.ordinal;
+    const covered = covers(ordinal);
+    if (!covered) {
+      partialIndex = partialIndex >= 0 ? Math.min(partialIndex, index) : index;
+      break;
+    }
+  }
+  let safeStart = partialIndex >= 0 ? Math.min(start, partialIndex) : start;
+  if (partialIndex >= 0 && partialIndex < start) {
+    while (safeStart > 0 && messages[safeStart]?.role !== "user")
+      safeStart--;
+    if (messages[safeStart]?.role !== "user")
+      return 0;
+  }
+  if (safeStart <= 0)
+    return 0;
+  messages.splice(0, safeStart);
+  return safeStart;
+}
+
+// src/v2/fold/host-media.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isClassInstance(value) {
+  if (!isRecord(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype !== Object.prototype && prototype !== null;
+}
+var rememberedAssetClass;
+var rememberedMessageClass;
+var schemaUsesAssets = new WeakMap;
+function rememberHostMedia(messages) {
+  for (const message of messages) {
+    if (!isClassInstance(message))
+      continue;
+    rememberedMessageClass ??= Object.getPrototypeOf(message).constructor;
+    if (rememberedAssetClass)
+      return;
+    const content = message.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const part of content) {
+      if (!isRecord(part) || part.type !== "media")
+        continue;
+      const media = part.media;
+      if (isClassInstance(media) && isRecord(media.source)) {
+        rememberedAssetClass = Object.getPrototypeOf(media).constructor;
+        return;
+      }
+    }
+  }
+}
+function hostUsesMediaAssets() {
+  const messageClass = rememberedMessageClass;
+  if (!messageClass)
+    return rememberedAssetClass !== undefined;
+  const cached = schemaUsesAssets.get(messageClass);
+  if (cached !== undefined)
+    return cached;
+  let uses = rememberedAssetClass !== undefined;
+  if (!uses) {
+    try {
+      uses = JSON.stringify(messageClass.ast).includes('"Media.Asset"');
+    } catch {
+      uses = false;
+    }
+  }
+  schemaUsesAssets.set(messageClass, uses);
+  return uses;
+}
+function decodeThroughHostSchema(source) {
+  const messageClass = rememberedMessageClass;
+  if (!messageClass)
+    return "no host message class seen";
+  const fields = messageClass.fields;
+  const union = fields?.content?.value;
+  const members = union?.members;
+  if (!Array.isArray(members))
+    return "host content schema has no union members";
+  const mediaPart = members.find((member) => {
+    const typeField = member?.fields;
+    const literal = typeField?.type?.ast?.literal;
+    return literal === "media";
+  });
+  const assetSchema = mediaPart?.fields?.media;
+  const encoding = assetSchema?.ast?.encoding;
+  const decode = Array.isArray(encoding) ? encoding[0]?.transformation?.decode : undefined;
+  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 option = result?._tag === "Success" ? result.value : undefined;
+  const asset = option?._tag === "Some" ? option.value : undefined;
+  if (!isClassInstance(asset) || asset.source !== source)
+    return "host media schema decode did not return an asset";
+  return asset;
+}
+function hostMediaAsset(data, mediaType) {
+  const source = { type: "base64", data, mediaType };
+  let first = "no Media.Asset seen in this process";
+  if (rememberedAssetClass) {
+    try {
+      return new rememberedAssetClass({ source });
+    } catch (error) {
+      first = `remembered asset class threw: ${String(error)}`;
+    }
+  }
+  let second;
+  try {
+    const decoded = decodeThroughHostSchema(source);
+    if (typeof decoded !== "string")
+      return decoded;
+    second = decoded;
+  } catch (error) {
+    second = `host media schema decode threw: ${String(error)}`;
+  }
+  return `${first}; ${second}`;
+}
+
+// src/v2/fold/owner.ts
+import { createHash } from "node:crypto";
+var foldDigest = (value) => createHash("sha256").update(value).digest("hex");
+
+class FoldOwner {
+  storage;
+  pending = new Map;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  async serial(sessionID, operation) {
+    const previous = this.pending.get(sessionID) ?? Promise.resolve();
+    const next = previous.catch(() => {}).then(operation);
+    this.pending.set(sessionID, next);
+    try {
+      return await next;
+    } finally {
+      if (this.pending.get(sessionID) === next)
+        this.pending.delete(sessionID);
+    }
+  }
+  key(sessionID) {
+    return `fold/v1/${sessionID}`;
+  }
+  async read(sessionID) {
+    return await this.storage.get(this.key(sessionID));
+  }
+  async supply(args) {
+    return this.serial(args.sessionID, async () => {
+      const previous = await this.read(args.sessionID);
+      const same = previous && (args.runningCut !== undefined ? previous.cutSeq === args.runningCut : previous.cutSeq === undefined && previous.watermark === args.watermark);
+      if (same)
+        return previous;
+      const submitted = args.materialize();
+      const next = {
+        watermark: args.watermark,
+        cutSeq: args.runningCut,
+        submitted,
+        submittedSha: foldDigest(submitted)
+      };
+      await this.storage.set(this.key(args.sessionID), next);
+      return next;
+    });
+  }
+  async observe(args) {
+    return this.serial(args.sessionID, async () => {
+      let state = await this.read(args.sessionID);
+      let changed = !state;
+      const renderedSha = foldDigest(JSON.stringify(args.rendered));
+      if (!state) {
+        args.onHard("boot_recovery");
+        state = {
+          watermark: args.cutSeq,
+          submitted: args.summary,
+          submittedSha: foldDigest(args.summary),
+          reason: "boot_recovery"
+        };
+      }
+      const reason = args.cutSeq < state.watermark ? "host_cut_before_watermark" : state.submittedSha !== foldDigest(args.summary) || state.renderedSha && state.renderedSha !== renderedSha ? "host_rerender" : undefined;
+      if (reason && state.rejectedSha !== renderedSha) {
+        args.onHard(reason);
+        state.reason = reason;
+        state.rejectedSha = renderedSha;
+        changed = true;
+      }
+      if (state.cutSeq === undefined && args.cutSeq >= state.watermark) {
+        state.cutSeq = args.cutSeq;
+        changed = true;
+      }
+      if (!state.rendered && reason !== "host_cut_before_watermark") {
+        state.rendered = structuredClone(args.rendered);
+        state.renderedSha = renderedSha;
+        state.renderedSummary = args.summary;
+        changed = true;
+      }
+      if (changed)
+        await this.storage.set(this.key(args.sessionID), state);
+      return state;
+    });
+  }
+}
+
+// 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") {
+    const skills = data.skills ?? [];
+    const content = [
+      ...skills.flatMap((skill) => skill.text === undefined ? [] : [{ type: "text", text: skill.text }]),
+      ...data.text ? [{ type: "text", text: data.text }] : [],
+      ...attachmentParts(data.files ?? [], row.id, media)
+    ];
+    return content.length ? [
+      make("user", content, {
+        ...data.metadata ?? {},
+        ...data.agents?.length ? { agents: data.agents } : {}
+      })
+    ] : [];
+  }
+  if (row.type === "system")
+    return [{ role: "system", content: [{ type: "text", text: data.text ?? "" }] }];
+  if (row.type === "synthetic" && isStorageNoticeText(data.text))
+    return [];
+  if (["synthetic", "skill"].includes(row.type))
+    return [make("user", [{ type: "text", text: data.text ?? "" }])];
+  if (row.type === "location-switched")
+    return [
+      make("user", [
+        {
+          type: "text",
+          text: `The working directory has been changed to ${data.location.directory}.`
+        }
+      ])
+    ];
+  if (row.type === "shell")
+    return data.metadata?.background === true ? [] : [
+      make("user", [
+        {
+          type: "text",
+          text: `The following shell command was executed by the user:
+
+Command:
+${data.command}
+
+Output:
+${data.output?.output ?? ""}`
+        }
+      ])
+    ];
+  if (row.type !== "assistant")
+    return [];
+  const previousModel = data.model;
+  const sameProvider = previousModel?.providerID === model.providerID;
+  const sameModel = sameProvider && previousModel?.id === model.id;
+  const reuse = sameModel && data.error === undefined;
+  const metadata = (state) => state === undefined ? undefined : { [model.providerID]: state };
+  const content = [];
+  const results = [];
+  for (const part of data.content ?? []) {
+    if (part.type === "text") {
+      if (part.text !== "")
+        content.push({
+          type: "text",
+          text: part.text,
+          providerMetadata: reuse ? metadata(part.state) : undefined
+        });
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (part.text !== "" || reuse && part.state !== undefined)
+        content.push({
+          type: reuse || data.error === undefined ? "reasoning" : "text",
+          text: part.text,
+          providerMetadata: reuse ? metadata(part.state) : undefined
+        });
+      continue;
+    }
+    const state = part.state;
+    const completed = state.status === "completed" || state.status === "error";
+    const toolReuse = reuse || sameModel && part.executed === true && completed;
+    let input = state.input;
+    if (state.status === "streaming" && typeof input === "string") {
+      try {
+        input = JSON.parse(input);
+      } catch {}
+    }
+    content.push({
+      type: "tool-call",
+      id: part.id,
+      name: part.name,
+      input,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
+    });
+    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
+var RAW_TYPES = new Set(RAW_MESSAGE_TYPES);
+function forkBoundarySeq(origin, sequenceForId) {
+  const seq = sequenceForId(origin.parentSessionID, origin.boundary.messageID);
+  if (seq === undefined)
+    return;
+  return origin.boundary.type === "before" ? seq - 1 : seq;
+}
+function buildForkIdMap(parentRows, forkRows, throughSeq) {
+  const parentBySeq = new Map;
+  for (const row of parentRows)
+    if (row.seq <= throughSeq)
+      parentBySeq.set(row.seq, row);
+  const parentToFork = new Map;
+  const forkOrdinals = new Map;
+  let ordinal = 0;
+  for (const row of forkRows) {
+    if (row.seq > throughSeq)
+      break;
+    if (RAW_TYPES.has(row.type)) {
+      ordinal += 1;
+      forkOrdinals.set(row.id, ordinal);
+    }
+    const parent = parentBySeq.get(row.seq);
+    if (parent && parent.type === row.type && parent.time_created === row.time_created && row.id !== parent.id && row.id.endsWith(`_${row.seq}`)) {
+      parentToFork.set(parent.id, row.id);
+    }
+  }
+  const parentOrdinals = new Map;
+  let parentOrdinal = 0;
+  for (const row of parentRows) {
+    if (row.seq > throughSeq)
+      break;
+    if (!RAW_TYPES.has(row.type))
+      continue;
+    parentOrdinal += 1;
+    parentOrdinals.set(parentOrdinal, row.id);
+  }
+  return { parentToFork, forkOrdinals, parentOrdinals, throughSeq };
+}
+var CONTENT_ID_SUFFIX = /(:(?:p|file)\d+)$/;
+var BLOCK_ID_SUFFIX = /(#\d+)$/;
+function splitMessageScopedId(id) {
+  const match = id.match(CONTENT_ID_SUFFIX) ?? id.match(BLOCK_ID_SUFFIX);
+  if (!match?.[1])
+    return { messageId: id, suffix: "" };
+  return { messageId: id.slice(0, -match[1].length), suffix: match[1] };
+}
+function forkCloneFilter(idMap, copiedToolCallIds) {
+  const mapMessageScoped = (id) => {
+    const direct = idMap.parentToFork.get(id);
+    if (direct)
+      return direct;
+    const { messageId, suffix } = splitMessageScopedId(id);
+    if (!suffix)
+      return;
+    const mapped = idMap.parentToFork.get(messageId);
+    return mapped ? `${mapped}${suffix}` : undefined;
+  };
+  return {
+    resolveBoundaryOrdinal: (messageId) => {
+      const forkId = idMap.parentToFork.get(messageId);
+      return forkId ? idMap.forkOrdinals.get(forkId) : undefined;
+    },
+    includeMessageId: (messageId) => mapMessageScoped(messageId) !== undefined || copiedToolCallIds.has(messageId),
+    mapMessageId: (messageId) => mapMessageScoped(messageId) ?? messageId,
+    includeTag: (tag) => {
+      if (tag.type === "tool") {
+        return tag.toolOwnerMessageId !== null && idMap.parentToFork.has(tag.toolOwnerMessageId);
+      }
+      return mapMessageScoped(tag.messageId) !== undefined;
+    },
+    mapOrdinal: (sourceOrdinal) => {
+      const parentId = idMap.parentOrdinals.get(sourceOrdinal);
+      const forkId = parentId ? idMap.parentToFork.get(parentId) : undefined;
+      return forkId ? idMap.forkOrdinals.get(forkId) : undefined;
+    },
+    copySessionNotesAndFacts: true,
+    selectPendingPiMarker: () => null
+  };
+}
+function countSessionRows(db, table, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE session_id = ?`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function sessionHasMagicContextState(db, sessionId) {
+  return countSessionRows(db, "compartments", sessionId) > 0 || countSessionRows(db, "tags", sessionId) > 0;
+}
+function seedV2ForkFromParent(args) {
+  const { db, store, sessionId } = args;
+  if (sessionHasMagicContextState(db, sessionId))
+    return { kind: "has-state" };
+  const origin = store.forkOrigin(sessionId);
+  if (!origin)
+    return { kind: "not-a-fork" };
+  const parentSessionID = origin.parentSessionID;
+  if (parentSessionID === sessionId)
+    return { kind: "not-a-fork" };
+  if (!sessionHasMagicContextState(db, parentSessionID))
+    return { kind: "parent-missing", parentSessionID, reason: "no Magic Context state" };
+  if (!store.sessionExists(parentSessionID))
+    return { kind: "parent-missing", parentSessionID, reason: "no host session row" };
+  const throughSeq = forkBoundarySeq(origin, (session, id) => store.sequenceForId(session, id));
+  if (throughSeq === undefined)
+    return { kind: "parent-missing", parentSessionID, reason: "boundary row not in the store" };
+  const idMap = buildForkIdMap(store.rowStampsThrough(parentSessionID, throughSeq), store.rowStampsThrough(sessionId, throughSeq), throughSeq);
+  if (idMap.parentToFork.size === 0)
+    return { kind: "parent-missing", parentSessionID, reason: "no copied rows pair up" };
+  const toolTags = db.prepare("SELECT message_id, tool_owner_message_id FROM tags WHERE session_id = ? AND type = 'tool'").all(parentSessionID);
+  const copiedToolCallIds = new Set(toolTags.filter((row) => row.tool_owner_message_id !== null && idMap.parentToFork.has(row.tool_owner_message_id)).map((row) => row.message_id));
+  const result = copySessionStateForClone(db, parentSessionID, sessionId, forkCloneFilter(idMap, copiedToolCallIds));
+  if (result.kind === "destination-not-empty")
+    return { kind: "destination-not-empty", parentSessionID };
+  return { kind: "seeded", parentSessionID, pairedRows: idMap.parentToFork.size, result };
+}
+
+// src/v2/hidden-child-record.ts
+function keptUnderRetention(keepSubagents, child) {
+  return keepSubagents && (child.ever_settled === true || child.role === "historian");
+}
+function roleTitle(role) {
+  return role === "historian" ? "Magic Context historian" : "Magic Context dreamer";
+}
+function roleAgent(role) {
+  if (role === "historian")
+    return HIDDEN_HISTORIAN_AGENT;
+  return role === "dreamer-curate" ? HIDDEN_CURATE_AGENT : HIDDEN_DREAMER_AGENT;
+}
+function childCreateInput(identity, role, model) {
+  return {
+    title: roleTitle(role),
+    agent: hiddenToolLoop(identity) ? hiddenAgentFor(identity) : roleAgent(role),
+    model: {
+      providerID: model.providerID,
+      id: model.modelID,
+      ...model.variant ? { variant: model.variant } : {}
+    },
+    location: { directory: identity.directory },
+    metadata: { magic_context: "hidden-run", role }
+  };
+}
+function assistantOutcome(row) {
+  const outcome = row?.data.outcome;
+  return outcome === "succeeded" || outcome === "failed" || outcome === "interrupted" ? outcome : undefined;
+}
+function withReader(openReader, read) {
+  const reader = openReader();
+  try {
+    return read(reader);
+  } finally {
+    reader.close?.();
+  }
+}
+function errorText(value) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/v2/hidden-child-native.ts
+function nativeSessionRemove(session) {
+  const remove = session.remove;
+  if (typeof remove !== "function")
+    return;
+  return (input) => Promise.resolve(remove.call(session, { sessionID: input.sessionID }));
+}
+function isSessionNotFound(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const fields = error;
+  if (fields.status === 404)
+    return true;
+  const label = [fields.name, fields._tag, fields.message].filter((value) => typeof value === "string").join(" ");
+  return /not\s*found/i.test(label);
+}
+var parentDroppedNoted = false;
+function createNativeHiddenChildren(host, removeSession, options) {
+  const removing = new Map;
+  const remove = (child) => {
+    const inFlight = removing.get(child.id);
+    if (inFlight)
+      return inFlight;
+    const done = (async () => {
+      try {
+        let timer;
+        try {
+          await Promise.race([
+            removeSession({ sessionID: child.id }),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error("session.remove timed out")), options.removalTimeoutMs ?? 5000);
+            })
+          ]);
+        } finally {
+          if (timer)
+            clearTimeout(timer);
+        }
+      } catch (error) {
+        if (isSessionNotFound(error))
+          return;
+        options.log(`[magic-context] hidden child ${child.id} could not be removed; it goes when its parent session is deleted: ${errorText(error)}`);
+      }
+    })().finally(() => {
+      removing.delete(child.id);
+    });
+    removing.set(child.id, done);
+    return done;
+  };
+  const confirmParent = async (sessionID, parentID) => {
+    let stored;
+    try {
+      stored = (await host.get({ sessionID })).parentID;
+    } catch (error) {
+      options.log(`[magic-context] could not read back hidden child ${sessionID} to confirm its parent: ${errorText(error)}`);
+      return;
+    }
+    if (stored === parentID || parentDroppedNoted)
+      return;
+    parentDroppedNoted = true;
+    options.log(`[magic-context] this OpenCode 2 host does not keep the parent of hidden-run sessions (asked for ${parentID}, read back ${stored ?? "none"}); they are created as separate sessions and still removed when each run ends`);
+  };
+  const create = async (identity, role, model) => {
+    const parentID = identity.parentSessionId;
+    const input = childCreateInput(identity, role, model);
+    const { location, ...parented } = input;
+    const created = await host.create(parentID ? { ...parented, parentID } : { ...parented, location });
+    if (!created.id)
+      throw new Error("OpenCode 2 did not return a child session id");
+    options.hook.registerChild(created.id);
+    if (parentID)
+      await confirmParent(created.id, parentID);
+    return {
+      id: created.id,
+      role,
+      generation: options.generation,
+      title: roleTitle(role),
+      model,
+      created_at: Date.now(),
+      directory: identity.directory
+    };
+  };
+  const kept = (child) => keptUnderRetention(options.keepSubagents, child);
+  return {
+    open: create,
+    create,
+    retire(child) {
+      if (!kept(child))
+        remove(child);
+    },
+    async finish(child, retired) {
+      if (retired) {
+        await removing.get(child.id);
+        return;
+      }
+      if (!kept(child))
+        await remove(child);
+    },
+    updateModel: (child, model) => ({ ...child, model }),
+    markEverSettled: (child) => ({ ...child, ever_settled: true })
+  };
+}
+
+// src/v2/hidden-child-cleanup.ts
+var PREFIX = "opencode2_hidden_children:";
+var COMPLETE = "opencode2_hidden_children_cleanup_complete";
+async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
+  if (db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key = ?").get(COMPLETE))
+    return;
+  const rows = db.prepare("SELECT key, value FROM schema_migrations_meta WHERE key GLOB ? ORDER BY key LIMIT 25").all(`${PREFIX}*`);
+  let remaining = options.limit ?? 25;
+  const now = options.now ?? (() => performance.now());
+  const deadline = now() + (options.budgetMs ?? 2000);
+  for (const row of rows) {
+    let record;
+    try {
+      record = JSON.parse(row.value);
+      if (!record || typeof record !== "object" || record.active !== undefined && (!record.active || typeof record.active !== "object" || Array.isArray(record.active)) || record.retired_children !== undefined && !Array.isArray(record.retired_children))
+        throw new Error("invalid record");
+    } catch {
+      note(`[magic-context] legacy hidden-child cleanup cannot read ${row.key}`);
+      continue;
+    }
+    const children = [
+      ...Object.values(record.active ?? {}),
+      ...record.retired_children ?? []
+    ];
+    for (const child of children) {
+      if (remaining-- <= 0 || now() >= deadline)
+        return;
+      if (typeof child?.id !== "string") {
+        note(`[magic-context] legacy hidden-child cleanup has an invalid child in ${row.key}`);
+        continue;
+      }
+      let timer;
+      try {
+        try {
+          await Promise.race([
+            remove({ sessionID: child.id }),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error("session.remove timed out")), Math.min(options.timeoutMs ?? 1000, Math.max(1, deadline - now())));
+            })
+          ]);
+        } catch (error) {
+          if (!isSessionNotFound(error))
+            throw error;
+        }
+        record.active = Object.fromEntries(Object.entries(record.active ?? {}).filter(([, entry]) => entry.id !== child.id));
+        record.retired_children = (record.retired_children ?? []).filter((entry) => entry.id !== child.id);
+        db.prepare("UPDATE schema_migrations_meta SET value = ? WHERE key = ?").run(JSON.stringify(record), row.key);
+      } catch (error) {
+        note(`[magic-context] legacy hidden child ${child.id} cleanup deferred: ${String(error)}`);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+      }
+    }
+    if (Object.keys(record.active ?? {}).length === 0 && (record.retired_children ?? []).length === 0)
+      db.prepare("DELETE FROM schema_migrations_meta WHERE key = ?").run(row.key);
+  }
+  if (!db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key GLOB ? LIMIT 1").get(`${PREFIX}*`))
+    db.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, 'true')").run(COMPLETE);
+}
+
+// src/v2/hidden-completion.ts
+var POLL_INTERVAL_MS = 200;
+function modelKey(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function sameModel(left, right) {
+  return modelKey(left) === modelKey(right) && left.variant === right.variant;
+}
+function configuredHead(identity) {
+  const candidates = [identity.model, ...identity.configuredModels ?? []];
+  for (const candidate of candidates) {
+    const entry = toModelEntry(candidate);
+    const parsed = entry ? parseProviderModel(entry.model) : null;
+    if (parsed)
+      return { ...parsed, ...entry?.qualifier ? { variant: entry.qualifier } : {} };
+  }
+  return;
+}
+function roleFor(identity) {
+  if (identity.kind !== "dreamer-task")
+    return "historian";
+  return identity.agent === HIDDEN_CURATE_AGENT ? "dreamer-curate" : "dreamer";
+}
+function promptText(request) {
+  const parts = request.body.parts;
+  return Array.isArray(parts) ? parts.flatMap((part) => part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []).join(`
+`) : "";
+}
+function meter(system, prompt, text) {
+  return {
+    input: estimateTokens(system) + estimateTokens(prompt),
+    output: estimateTokens(text),
+    cacheRead: 0,
+    cacheWrite: 0
+  };
+}
+function toolResultText(result) {
+  if (typeof result !== "object" || result === null)
+    return;
+  const value = result.value;
+  if (typeof value === "string")
+    return value;
+  if (!Array.isArray(value))
+    return;
+  const text = value.map((part) => typeof part === "object" && part !== null && typeof part.text === "string" ? part.text : "").filter((part) => part.length > 0).join(`
+`);
+  return text.length > 0 ? text : undefined;
+}
+function toolLoopMessages(attempt) {
+  const messages = attempt.observedMessages ?? [];
+  const results = new Map;
+  for (const message of messages) {
+    if (message.role !== "tool")
+      continue;
+    for (const part of message.content) {
+      if (part.type !== "tool-result" || typeof part.id !== "string")
+        continue;
+      const result = part.result;
+      const failed = result?.type === "error" || part.resultType === "error" || typeof result === "object" && result !== null && "error" in result;
+      const output = failed ? undefined : toolResultText(result);
+      results.set(part.id, {
+        status: failed ? "error" : "completed",
+        ...output === undefined ? {} : { output }
+      });
+    }
+  }
+  return messages.flatMap((message) => {
+    if (message.role !== "assistant")
+      return [];
+    const parts = message.content.flatMap((part) => {
+      if (part.type !== "tool-call" || typeof part.id !== "string" || typeof part.name !== "string")
+        return [];
+      const result = results.get(part.id);
+      return [
+        {
+          type: "tool",
+          tool: part.name,
+          state: {
+            status: result?.status ?? "pending",
+            input: part.input,
+            ...result?.output === undefined ? {} : { output: result.output }
+          }
+        }
+      ];
+    });
+    return parts.length ? [{ info: { role: "assistant" }, parts }] : [];
+  });
+}
+function assistantReasoning(row) {
+  const reasoning = (row.data.content ?? []).flatMap((part) => part.type === "reasoning" && typeof part.text === "string" ? [part.text] : []).join(`
+`);
+  return reasoning.length > 0 ? reasoning : null;
+}
+function assistantText(row) {
+  const text = (row.data.content ?? []).flatMap((part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("");
+  return text.length > 0 ? text : null;
+}
+
+class HiddenProviderError extends Error {
+  settled;
+  constructor(detail, options = {}) {
+    super(`Hidden completion provider error: ${detail}`);
+    this.name = "HiddenProviderError";
+    this.settled = options.settled ?? true;
+  }
+}
+function requestModel(request, current) {
+  const requested = request.body.model;
+  if (requested && typeof requested.providerID === "string" && typeof requested.modelID === "string") {
+    return {
+      providerID: requested.providerID,
+      modelID: requested.modelID,
+      ...typeof request.body.variant === "string" ? { variant: request.body.variant } : {}
+    };
+  }
+  return current;
+}
+async function sleepUntilPoll(signal, deadline) {
+  if (signal?.aborted)
+    throw new Error("Hidden completion prompt aborted");
+  const delay = Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now()));
+  if (delay <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delay);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(new Error("Hidden completion prompt aborted"));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted)
+      abort();
+    else
+      setTimeout(() => {
+        signal?.removeEventListener("abort", abort);
+      }, delay);
+  });
+}
+function isProviderFailure(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const type = error.type;
+  return typeof type === "string" && (type.startsWith("provider.") || type.toLowerCase().includes("provider"));
+}
+async function awaitAssistantRow(openReader, readSessionError, localFailure, childID, afterSeq, deadline, signal) {
+  for (;; ) {
+    const { assistant, idle } = withReader(openReader, (reader) => ({
+      assistant: reader.latestAssistant(childID),
+      idle: reader.latestIdle(childID)
+    }));
+    const newAssistant = assistant && assistant.seq > afterSeq ? assistant : undefined;
+    const newIdle = idle && idle.seq > afterSeq ? idle : undefined;
+    const refused = localFailure();
+    if (refused)
+      throw refused;
+    if (newIdle && (!newAssistant || newIdle.seq > newAssistant.seq)) {
+      const outcome = newIdle.data.outcome;
+      if (outcome === "failed" || outcome === "interrupted") {
+        const sessionError = await readSessionError();
+        const details = [
+          `outcome=${outcome}`,
+          `terminal_row=${errorText(newIdle)}`,
+          `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
+        ];
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+      }
+      if (outcome === "succeeded" && newAssistant)
+        return newAssistant;
+    }
+    if (newAssistant) {
+      const outcome = assistantOutcome(newAssistant);
+      if (outcome === "failed" || outcome === "interrupted") {
+        const sessionError = await readSessionError();
+        const details = [
+          `outcome=${outcome}`,
+          `terminal_row=${errorText(newAssistant)}`,
+          `session_error=${sessionError === undefined ? "unavailable" : errorText(sessionError)}`
+        ];
+        throw sessionError === undefined || !isProviderFailure(sessionError) ? new Error(`Hidden completion failed: ${details.join("; ")}`) : new HiddenProviderError(details.join("; "));
+      }
+      if (newAssistant.data.error !== undefined) {
+        throw new HiddenProviderError(errorText(newAssistant.data.error), {
+          settled: typeof newAssistant.data.finish === "string"
+        });
+      }
+      if (typeof newAssistant.data.finish === "string" || outcome === "succeeded") {
+        return newAssistant;
+      }
+    }
+    if (Date.now() >= deadline) {
+      throw new Error("Hidden completion timed out waiting for a persisted assistant row");
+    }
+    await sleepUntilPoll(signal, deadline);
+  }
+}
+var V2_HIDDEN_EXECUTOR_CAPABILITIES = {
+  tools: true,
+  harness: "opencode2"
+};
+function createLateHiddenExecutor(current) {
+  const wired = () => {
+    const executor = current();
+    if (executor)
+      return executor;
+    throw new Error("Magic Context hidden work is unavailable until the context database opens.");
+  };
+  return {
+    get capabilities() {
+      return current()?.capabilities ?? V2_HIDDEN_EXECUTOR_CAPABILITIES;
+    },
+    open: (run) => wired().open(run),
+    attempt: (handle, request) => wired().attempt(handle, request),
+    collect: (handle, limit) => wired().collect(handle, limit),
+    close: (handle, settlement) => wired().close(handle, settlement)
+  };
+}
+async function createV2HiddenCompletionExecutor(host, options) {
+  const runs = new WeakMap;
+  const generation = options.generation ?? "opencode2";
+  const roleTails = new Map;
+  const note = options.log ?? log;
+  const removeSession = host.removeSession;
+  if (!removeSession)
+    throw new Error("Magic Context requires OpenCode 2.0.22 session.remove");
+  const lifecycle = createNativeHiddenChildren(host, (input) => removeSession.call(host, input), {
+    hook: options.hook,
+    generation,
+    keepSubagents: options.keepSubagents === true,
+    log: note,
+    removalTimeoutMs: options.removalTimeoutMs
+  });
+  const acquireRole = async (role) => {
+    const previous = roleTails.get(role) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = previous.then(() => gate);
+    roleTails.set(role, tail);
+    await previous;
+    return () => {
+      release();
+      if (roleTails.get(role) === tail)
+        roleTails.delete(role);
+    };
+  };
+  const warnedVariants = new Set;
+  const validateVariant = async (model) => {
+    if (!model.variant || !options.modelCatalog)
+      return model;
+    try {
+      const listed = await options.modelCatalog();
+      const rows = Array.isArray(listed) ? listed : listed && typeof listed === "object" && Array.isArray(listed.data) ? listed.data : [];
+      const entry = rows.find((row) => row && typeof row === "object" && row.providerID === model.providerID && row.id === model.modelID);
+      if (!entry)
+        return model;
+      if (entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
+        return model;
+      const key = `${model.providerID}/${model.modelID}:${model.variant}`;
+      if (!warnedVariants.has(key)) {
+        warnedVariants.add(key);
+        note(`[magic-context] ${recordHiddenVariantWarning(model.providerID, model.modelID, model.variant)}`);
+      }
+      return { providerID: model.providerID, modelID: model.modelID };
+    } catch {
+      return model;
+    }
+  };
+  const resolveHead = async (identity) => {
+    const configured = configuredHead(identity);
+    if (configured)
+      return validateVariant(configured);
+    if (!identity.parentSessionId) {
+      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion requires a configured model or an existing parent session model", true);
+    }
+    const parent = await host.get({ sessionID: identity.parentSessionId });
+    if (!parent.model) {
+      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion could not resolve the parent session model", true);
+    }
+    return {
+      providerID: parent.model.providerID,
+      modelID: parent.model.id,
+      ...parent.model.variant ? { variant: parent.model.variant } : {}
+    };
+  };
+  const switchChildModel = async (run, requested) => {
+    if (sameModel(run.child.model, requested))
+      return;
+    await host.switchModel({
+      sessionID: run.child.id,
+      model: {
+        providerID: requested.providerID,
+        id: requested.modelID,
+        ...requested.variant ? { variant: requested.variant } : {}
+      }
+    });
+    run.child = lifecycle.updateModel(run.child, requested);
+  };
+  const retire = (run, reason) => {
+    if (run.retired)
+      return;
+    lifecycle.retire(run.child, reason);
+    run.retired = true;
+  };
+  const interruptAndRetire = async (run, reason) => {
+    try {
+      await host.interrupt({ sessionID: run.child.id });
+    } finally {
+      retire(run, reason);
+    }
+  };
+  return {
+    capabilities: V2_HIDDEN_EXECUTOR_CAPABILITIES,
+    async open(identity) {
+      const role = roleFor(identity);
+      const releaseRole = await acquireRole(role);
+      let openedChild;
+      try {
+        await options.ensureAgent?.();
+        const head = await resolveHead(identity);
+        const active = await lifecycle.open(identity, role, head);
+        openedChild = active;
+        const handle = { id: active.id, childSessionId: active.id };
+        const tokenBudget = identity.metadata?.tokenBudget;
+        const run = {
+          identity,
+          ...hiddenToolLoop(identity) && typeof tokenBudget === "number" ? { budget: createDreamTokenBudget(tokenBudget) } : {},
+          role,
+          child: active,
+          releaseRole,
+          failed: false,
+          unsettledFailure: false,
+          retired: false
+        };
+        runs.set(handle, run);
+        await switchChildModel(run, head);
+        return handle;
+      } catch (error) {
+        if (openedChild)
+          lifecycle.retire(openedChild, "hidden-run-open-failed");
+        releaseRole();
+        throw error;
+      }
+    },
+    async attempt(handle, request) {
+      const run = runs.get(handle);
+      if (!run)
+        throw new Error("Unknown hidden completion run");
+      if (request.signal?.aborted) {
+        await interruptAndRetire(run, "aborted-before-prompt");
+        throw new Error("Hidden completion prompt aborted");
+      }
+      const requested = await validateVariant(requestModel(request, run.child.model));
+      if (run.retired) {
+        run.child = await lifecycle.create(run.identity, run.role, requested);
+        run.failed = false;
+        run.unsettledFailure = false;
+        run.retired = false;
+        handle.id = run.child.id;
+        handle.childSessionId = run.child.id;
+      }
+      await switchChildModel(run, requested);
+      const baseline = withReader(options.openReader, (reader) => reader.latestSequence(run.child.id));
+      const marker = `mc:hidden:${crypto.randomUUID()}:${crypto.randomUUID()}`;
+      run.completion = undefined;
+      const attempt = {
+        childSessionId: run.child.id,
+        identity: run.identity,
+        request,
+        shaped: false,
+        budget: run.budget
+      };
+      options.hook.registerAttempt(marker, attempt);
+      const deadline = Date.now() + run.identity.timeoutMs;
+      const budget = run.budget;
+      if (budget?.snapshot().finalizeFired) {
+        throw new DreamTokenBudgetExceeded(run.child.id, budget.snapshot().spent);
+      }
+      let usageSeq = baseline;
+      let budgetPoll;
+      let budgetReject;
+      const budgetStopped = new Promise((_resolve, reject) => {
+        budgetReject = reject;
+      });
+      if (budget) {
+        budgetPoll = setInterval(() => {
+          try {
+            const fresh = withReader(options.openReader, (reader) => reader.assistantSince?.(run.child.id, usageSeq) ?? (() => {
+              const latest = reader.latestAssistant(run.child.id);
+              return latest ? [latest] : [];
+            })());
+            for (const row of fresh) {
+              if (row.seq <= usageSeq)
+                continue;
+              usageSeq = row.seq;
+              const tokens = row.data.tokens;
+              const decision = budget.charge(Math.max(0, tokens?.input ?? 0), Math.max(0, tokens?.cache?.read ?? 0), Math.max(0, tokens?.cache?.write ?? 0), row.data.finish === "stop" && !(row.data.content ?? []).some((part) => part.type === "tool-call"), false);
+              const onBudgetUpdate = run.identity.metadata?.onBudgetUpdate;
+              if (typeof onBudgetUpdate === "function")
+                onBudgetUpdate({ ...budget.snapshot(), sessionId: run.child.id });
+              if (decision !== "continue") {
+                if (budgetPoll)
+                  clearInterval(budgetPoll);
+                attempt.budgetExceeded = new DreamTokenBudgetExceeded(run.child.id, budget.snapshot().spent);
+                interruptAndRetire(run, "token-budget").finally(() => budgetReject(attempt.budgetExceeded));
+                return;
+              }
+            }
+          } catch (error) {
+            if (budgetPoll)
+              clearInterval(budgetPoll);
+            budgetReject(error instanceof Error ? error : new Error(String(error)));
+          }
+        }, POLL_INTERVAL_MS);
+      }
+      let abortReject;
+      const aborted = new Promise((_resolve, reject) => {
+        abortReject = reject;
+      });
+      const onAbort = () => {
+        interruptAndRetire(run, "prompt-aborted").finally(() => abortReject(new Error("Hidden completion prompt aborted")));
+      };
+      const deadlineTimer = setTimeout(() => {
+        interruptAndRetire(run, "prompt-timeout").finally(() => abortReject(new Error("Hidden completion prompt timed out")));
+      }, Math.max(0, deadline - Date.now()));
+      request.signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        await Promise.race([
+          host.prompt({ sessionID: run.child.id, text: marker }),
+          aborted,
+          ...budget ? [budgetStopped] : []
+        ]);
+        await Promise.race([
+          host.wait({ sessionID: run.child.id }),
+          aborted,
+          ...budget ? [budgetStopped] : []
+        ]);
+        const row = await Promise.race([
+          awaitAssistantRow(options.openReader, async () => {
+            try {
+              const eventError = await host.terminalError?.({
+                sessionID: run.child.id
+              });
+              if (eventError !== undefined)
+                return eventError;
+              return (await host.get({ sessionID: run.child.id })).error;
+            } catch {
+              return;
+            }
+          }, () => attempt.refusal ?? attempt.stepLimit, run.child.id, baseline, deadline, request.signal),
+          aborted,
+          ...budget ? [budgetStopped] : []
+        ]);
+        if (!attempt.shaped) {
+          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Host did not dispatch the hidden child context hook", true);
+        }
+        const text = assistantText(row);
+        const system = typeof request.body.system === "string" ? request.body.system : run.identity.system;
+        const tokens = row.data.tokens;
+        const tokenNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+        const reportedInput = tokenNumber(tokens?.input);
+        const reportedOutput = tokenNumber(tokens?.output);
+        if (request.signal?.aborted || run.retired || Date.now() >= deadline) {
+          await interruptAndRetire(run, "prompt-aborted-or-timeout");
+          throw new Error(request.signal?.aborted ? "Hidden completion prompt aborted" : "Hidden completion prompt timed out");
+        }
+        run.completion = {
+          text,
+          tokenLog: runTokenLog(tokens, run.identity.maxOutputTokens, row.data.finish),
+          ...hiddenToolLoop(run.identity) ? { messages: toolLoopMessages(attempt) } : {},
+          reasoning: text ? null : assistantReasoning(row),
+          usage: reportedInput !== undefined || reportedOutput !== undefined ? {
+            input: reportedInput ?? 0,
+            output: reportedOutput ?? 0,
+            cacheRead: tokenNumber(tokens?.cache?.read) ?? 0,
+            cacheWrite: tokenNumber(tokens?.cache?.write) ?? 0
+          } : meter(system, promptText(request), text ?? ""),
+          lengthCapped: ["length", "max_tokens"].includes(row.data.finish ?? ""),
+          providerId: row.data.model?.providerID ?? requested.providerID,
+          modelId: row.data.model?.id ?? requested.modelID
+        };
+        if (!run.child.ever_settled)
+          run.child = lifecycle.markEverSettled(run.child);
+      } catch (caught) {
+        const error = attempt.budgetExceeded ?? attempt.stepLimit ?? attempt.refusal ?? caught;
+        run.failed = true;
+        if (!(error instanceof HiddenProviderError)) {
+          run.unsettledFailure = true;
+        }
+        if (request.signal?.aborted && !run.retired) {
+          await interruptAndRetire(run, "prompt-aborted");
+        } else if (error instanceof Error && error.message.includes("timed out") && !run.retired) {
+          await interruptAndRetire(run, "prompt-timeout");
+        } else if ((error instanceof HiddenAgentStepLimit || error instanceof HiddenProviderError && error.settled) && !run.retired) {
+          await interruptAndRetire(run, error instanceof HiddenAgentStepLimit ? "hidden-run-step-limit" : "hidden-run-provider-error");
+        }
+        throw error;
+      } finally {
+        clearTimeout(deadlineTimer);
+        if (budgetPoll)
+          clearInterval(budgetPoll);
+        request.signal?.removeEventListener("abort", onAbort);
+        options.hook.releaseAttempt(marker);
+      }
+    },
+    async collect(handle) {
+      const completion = runs.get(handle)?.completion;
+      if (!completion)
+        throw new Error("Hidden completion has no settled output");
+      return completion;
+    },
+    async close(handle, settlement) {
+      if (!handle)
+        return;
+      const run = runs.get(handle);
+      if (!run)
+        return;
+      try {
+        const reusable = !run.retired && run.failed && !run.unsettledFailure;
+        if (hiddenToolLoop(run.identity)) {
+          retire(run, settlement.promptSettled ? "tool-loop-settled" : "tool-loop-failed");
+        } else if (!run.completion && (run.failed || !settlement.promptSettled) && !reusable) {
+          retire(run, "hidden-run-failed");
+        }
+      } finally {
+        runs.delete(handle);
+        run.releaseRole();
+      }
+      await lifecycle.finish(run.child, run.retired);
+    }
+  };
+}
+
+// src/v2/hooks/channel2.ts
+import { randomBytes } from "node:crypto";
+var pendingCandidates = new WeakMap;
+function syntheticCandidates(context, sessionID, stored) {
+  const pending = pendingCandidates.get(context.storage);
+  for (const [key, id] of pending ?? []) {
+    if (!key.startsWith(`${sessionID}/`))
+      continue;
+    if (stored.has(id))
+      pending?.delete(key);
+    else
+      stored.add(id);
+  }
+  return stored;
+}
+function clearSyntheticCandidates(context) {
+  pendingCandidates.delete(context.storage);
+}
+async function deliverSynthetic(context, sessionID, text) {
+  const id = `msg_${randomBytes(12).toString("hex")}`;
+  await context.storage.set(`synthetic/${sessionID}/${id}`, { id });
+  let candidates = pendingCandidates.get(context.storage);
+  if (!candidates) {
+    candidates = new Map;
+    pendingCandidates.set(context.storage, candidates);
+  }
+  candidates.set(`${sessionID}/${id}`, id);
+  await context.session.synthetic({ sessionID, id, text, delivery: "steer" });
+  return id;
+}
+async function isAdmittedSynthetic(context, sessionID, id) {
+  const record = await context.storage.get(`synthetic/${sessionID}/${id}`);
+  return record !== null && typeof record === "object" && "id" in record && record.id === id;
+}
+async function deliverPendingChannel2(context, db, sessionID, baseline) {
+  if (getChannel2NudgeState(db, sessionID) !== "pending")
+    return;
+  const evaluation = evaluateChannel2(baseline);
+  if (!evaluation.evaluable || !evaluation.shouldTrigger)
+    return;
+  const token = randomBytes(16).toString("hex");
+  if (!claimChannel2NudgeState(db, sessionID, token))
+    return;
+  try {
+    await deliverSynthetic(context, sessionID, buildChannel2Reminder(evaluation.reclaimableTokens, reclaimableToolOutputCount(baseline?.baselineParts ?? [])));
+  } catch (error) {
+    casChannel2NudgeClaim(db, sessionID, "pending", token);
+    throw error;
+  }
+  casChannel2NudgeClaim(db, sessionID, "delivered", token);
+}
+
+// src/v2/hooks/commands.ts
+async function registerV2Commands(args) {
+  const domain = args.command;
+  if (!domain || typeof domain.transform !== "function") {
+    log("[magic-context] v2 host exposes no command domain; /ctx-* commands are TUI-only");
+    return false;
+  }
+  const descriptions = getMagicContextBuiltinCommands(args.compactionEnabled);
+  const commands = buildV2Commands(args.rpc, args.directory);
+  try {
+    await domain.transform((editor) => {
+      for (const command of commands) {
+        editor.add({
+          name: command.name,
+          description: descriptions[command.name].description,
+          execute: command.execute
+        });
+      }
+    });
+  } catch (error) {
+    log("[magic-context] v2 command registration failed", error);
+    return false;
+  }
+  log(`[magic-context] registered server-side commands: ${commands.map((command) => command.name).join(" ")}`);
+  return true;
+}
+function commandArgument(input, name) {
+  const raw = typeof input.prompt?.text === "string" ? input.prompt.text.trim() : "";
+  const prefix = `/${name}`;
+  if (raw === prefix)
+    return "";
+  if (raw.startsWith(`${prefix} `))
+    return raw.slice(prefix.length).trim();
+  return raw;
+}
+function reportResult(sessionID, title, message) {
+  pushNotification2("action", { action: "show-result-dialog", title, message }, sessionID);
+}
+function reportUsage(sessionID, message) {
+  pushNotification2("toast", { message, variant: "warning" }, sessionID);
+}
+function reportRpcReply(sessionID, title, reply, pending) {
+  if (reply.ok !== true) {
+    const error = typeof reply.error === "string" ? reply.error : `${title} request failed`;
+    pushNotification2("toast", { message: error, variant: "error" }, sessionID);
+    return;
+  }
+  if (reply.started === true) {
+    pushNotification2("toast", { message: pending, variant: "info" }, sessionID);
+    return;
+  }
+  reportResult(sessionID, title, typeof reply.message === "string" ? reply.message : "");
+}
+function buildV2Commands(rpc, directory) {
+  return [
+    {
+      name: "ctx-status",
+      execute: async (input) => {
+        const detail = await rpc.dispatch("status-detail", {
+          sessionId: input.sessionID,
+          directory
+        });
+        if (typeof detail.error === "string") {
+          throw new Error(`Magic Context status is unavailable: ${detail.error}`);
+        }
+        pushNotification2("action", { action: "show-status-dialog" }, input.sessionID);
+      }
+    },
+    {
+      name: "ctx-recomp",
+      execute: async (input) => {
+        if (isTuiConnected2(input.sessionID)) {
+          pushNotification2("action", { action: "show-recomp-dialog" }, input.sessionID);
+          return;
+        }
+        const reply = await rpc.dispatch("recomp", { sessionId: input.sessionID });
+        if (reply.ok !== true) {
+          throw new Error("Magic Context could not start the history rebuild.");
+        }
+      }
+    },
+    {
+      name: "ctx-dream",
+      execute: async (input) => {
+        const task = commandArgument(input, "ctx-dream");
+        const reply = await rpc.dispatch("dream", {
+          sessionId: input.sessionID,
+          ...task ? { task } : {}
+        });
+        if (reply.ok !== true) {
+          const error = typeof reply.error === "string" ? reply.error : "dream request failed";
+          throw new Error(`Magic Context could not start the dream run: ${error}`);
+        }
+      }
+    },
+    {
+      name: "ctx-flush",
+      execute: async (input) => {
+        const reply = await rpc.dispatch("flush", { sessionId: input.sessionID });
+        reportRpcReply(input.sessionID, "Flush", reply, "Flush started");
+      }
+    },
+    {
+      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 };
+    },
+    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
+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;
+        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?.();
+          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);
+        }
+      }
+    } 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/payload.ts
+var HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
+var HOST_CONTENT_TYPES = new Set([
+  "text",
+  "media",
+  "tool-call",
+  "tool-result",
+  "reasoning",
+  "compaction",
+  "effort"
+]);
+function rejectContentPart(message, part, reason) {
+  const type = typeof part.type === "string" ? part.type : "<missing>";
+  const text = `v2 context omitted a content part the host would reject: type=${type} message=${String(message.info.id ?? "<head>")} reason=${reason}`;
+  if (typeof message.info.sessionID === "string")
+    sessionLog(message.info.sessionID, text);
+  else
+    log(text);
+}
+function isHostInstance(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype !== Object.prototype && prototype !== null;
+}
+function containsHostInstance(value) {
+  if (isHostInstance(value))
+    return true;
+  if (Array.isArray(value))
+    return value.some(containsHostInstance);
+  if (value && typeof value === "object")
+    return Object.values(value).some(containsHostInstance);
+  return false;
+}
+function 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 (Array.isArray(entry))
+      return entry.map(plain);
+    if (entry && typeof entry === "object") {
+      return Object.fromEntries(Object.entries(entry).map(([key, nested]) => [key, plain(nested)]));
+    }
+    return entry;
+  };
+  return JSON.stringify(plain(value));
+}
+function fileContentValue(result) {
+  const value = result?.value;
+  if (result?.type !== "content" || !Array.isArray(value))
+    return;
+  return value.some((item) => item?.type === "file") ? value : undefined;
+}
+function contentValueText(value) {
+  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
+`);
+}
+function contentValueAttachments(value) {
+  return value.filter((item) => item?.type === "file").map((item) => ({
+    type: "file",
+    mime: item.mime,
+    url: item.uri,
+    ...typeof item.name === "string" ? { filename: item.name } : {}
+  }));
+}
+function rebuildFileContent(value, output) {
+  if (isDroppedToolOutput(output))
+    return { type: "text", value: output };
+  const rebuilt = [];
+  let placed = false;
+  for (const item of value) {
+    if (item?.type !== "text") {
+      rebuilt.push(item);
+      continue;
+    }
+    if (placed)
+      continue;
+    placed = true;
+    rebuilt.push({ ...item, text: output });
+  }
+  if (!placed && output)
+    rebuilt.unshift({ type: "text", text: output });
+  return { type: "content", value: rebuilt };
+}
+function adaptPayload(draft, admittedIDs = new Set) {
+  const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
+  const source = draft.messages.filter((m) => !existingHeads.has(m.id));
+  const results = new Map;
+  const hostParts = new Map;
+  const hostPartTypes = new Set;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
+        const key = contentKey(part);
+        if (!hostParts.has(key))
+          hostParts.set(key, part);
+        hostPartTypes.add(part.type);
+      }
+      if (part.type === "tool-result" && typeof part.id === "string") {
+        const queue = results.get(part.id) ?? [];
+        queue.push({ part, message });
+        results.set(part.id, queue);
+      }
+    }
+  }
+  const paired = new Set;
+  const bridges = new Map;
+  const originals = new Map;
+  const bridgesByMessageID = new Map;
+  const bridgesByCarrier = new Map;
+  const originalsByID = new Map;
+  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
+  const nativeTool = (call, result) => {
+    const hostResult = result?.part.result;
+    const failed = result !== undefined && isToolError(result.part);
+    const value = hostResult?.value;
+    const files = fileContentValue(hostResult);
+    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
+    const part = {
+      type: "tool",
+      callID: call?.id ?? result?.part.id,
+      tool: call?.name ?? result?.part.name,
+      state: {
+        input: structuredClone(call?.input ?? {}),
+        status: failed ? "error" : result ? "completed" : "running",
+        ...result ? { output } : {},
+        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
+        ...files ? { attachments: contentValueAttachments(files) } : {}
+      }
+    };
+    bridges.set(part, {
+      call,
+      result: result?.part,
+      resultMessage: result?.message,
+      output,
+      files
+    });
+    if (result)
+      paired.add(result.part);
+    return part;
+  };
+  const convertedTool = (source) => {
+    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
+    const output = toolStateContent(sourceState);
+    const { content: _content, ...projectedState } = structuredClone(sourceState);
+    const part = {
+      type: "tool",
+      callID: source.callID ?? source.id,
+      tool: source.tool ?? source.name,
+      state: { ...projectedState, output }
+    };
+    bridges.set(part, { native: source, output });
+    return part;
+  };
+  const callParts = new Map;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type === "tool-call") {
+        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
+      } else if (part.type === "tool") {
+        callParts.set(part, convertedTool(part));
+      }
+    }
+  }
+  const messages = [];
+  for (const message of source) {
+    const parts = [];
+    for (const content of message.content) {
+      if (paired.has(content))
+        continue;
+      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
+      if (message.id && admittedIDs.has(message.id))
+        part.synthetic = true;
+      parts.push(part);
+    }
+    if (!parts.length && message.content.length)
+      continue;
+    const byCallID = new Map;
+    for (const part of parts) {
+      const bridge = bridges.get(part);
+      if (bridge && typeof part.callID === "string")
+        byCallID.set(part.callID, bridge);
+    }
+    if (typeof message.id === "string") {
+      bridgesByMessageID.set(message.id, byCallID);
+      originalsByID.set(message.id, message);
+    }
+    const mapped = {
+      info: {
+        id: message.id,
+        sessionID: draft.sessionID,
+        role: message.role,
+        ...{
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agent: draft.agent
+        }
+      },
+      parts
+    };
+    originals.set(mapped, message);
+    if (typeof message.id !== "string")
+      bridgesByCarrier.set(mapped, byCallID);
+    messages.push(mapped);
+  }
+  return {
+    messages,
+    commit() {
+      let head = 0;
+      const rendered = [];
+      for (const message of messages) {
+        const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
+        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
+        const content = [];
+        const following = [];
+        for (const candidate of message.parts) {
+          const part = candidate;
+          const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
+          if (!bridge) {
+            if (part.type === "tool") {
+              const state = part.state;
+              if (typeof part.callID !== "string" || typeof part.tool !== "string" || !state || typeof state !== "object") {
+                rejectContentPart(message, part, "tool has no call ID, name, or state");
+                continue;
+              }
+              content.push({
+                type: "tool-call",
+                id: part.callID,
+                name: part.tool,
+                input: state.input
+              });
+              if (state.status === "completed" || state.status === "error") {
+                following.push({
+                  role: "tool",
+                  content: [
+                    {
+                      type: "tool-result",
+                      id: part.callID,
+                      name: part.tool,
+                      result: {
+                        type: state.status === "error" ? "error" : "text",
+                        value: toolStateContent(state)
+                      }
+                    }
+                  ]
+                });
+              }
+              continue;
+            }
+            if (part.type === "file") {
+              const mime = part.mime;
+              const url = part.url;
+              const prefix = `data:${mime};base64,`;
+              if (typeof mime !== "string" || !/^image\/(png|jpeg|gif|webp)$/.test(mime) || typeof url !== "string" || !url.startsWith(prefix)) {
+                rejectContentPart(message, part, "file is not an inline supported image");
+                continue;
+              }
+              const asset = hostMediaAsset(url.slice(prefix.length), mime);
+              if (typeof asset === "string") {
+                rejectContentPart(message, part, `host media unavailable: ${asset}`);
+                continue;
+              }
+              content.push({ type: "media", media: asset });
+              continue;
+            }
+            if (!HOST_CONTENT_TYPES.has(String(part.type))) {
+              rejectContentPart(message, part, "unknown host content type");
+              continue;
+            }
+            const { synthetic: _synthetic, ...clean } = part;
+            const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
+            content.push(original ?? clean);
+            continue;
+          }
+          const state = part.state;
+          if (bridge.native) {
+            const native = bridge.native;
+            const callID = String(native.id ?? native.callID ?? part.callID);
+            const name = String(native.name ?? native.tool ?? part.tool);
+            content.push({ type: "tool-call", id: callID, name, input: state.input });
+            if (state.status === "completed" || state.status === "error") {
+              following.push({
+                role: "tool",
+                content: [
+                  {
+                    type: "tool-result",
+                    id: callID,
+                    name,
+                    result: {
+                      type: state.status === "error" ? "error" : "text",
+                      value: state.output
+                    }
+                  }
+                ]
+              });
+            }
+            continue;
+          }
+          if (bridge.call)
+            content.push({ ...bridge.call, input: state.input });
+          if (bridge.result && bridge.resultMessage) {
+            const result = {
+              ...bridge.result,
+              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
+                type: state.status === "error" ? "error" : "text",
+                value: state.output
+              }
+            };
+            if (bridge.resultMessage === original)
+              content.push(result);
+            else
+              following.push({ ...bridge.resultMessage, content: [result] });
+          }
+        }
+        if (content.length || !original?.content.length) {
+          const value = {
+            ...original,
+            id,
+            role: message.info.role ?? "user",
+            content
+          };
+          const existing = id ? existingHeads.get(id) : undefined;
+          rendered.push(existing ? Object.assign(existing, { content }) : value);
+        }
+        rendered.push(...following);
+      }
+      draft.messages.splice(0, draft.messages.length, ...rendered);
+    }
+  };
+}
+
+// src/v2/hooks/generate.ts
+class V2GenerateReplay {
+  prefixes = new Map;
+  capture(draft, anchor) {
+    if (!anchor)
+      return;
+    this.prefixes.set(draft.sessionID, {
+      anchor,
+      model: `${draft.model.providerID}/${draft.model.id}`,
+      agent: draft.agent,
+      system: clonePreservingInstances(draft.system),
+      messages: clonePreservingInstances(draft.messages),
+      tools: clonePreservingInstances(draft.tools)
+    });
+  }
+  forget(sessionID) {
+    this.prefixes.delete(sessionID);
+  }
+  apply(draft) {
+    const prefix = this.prefixes.get(draft.sessionID);
+    if (!prefix || prefix.model !== `${draft.model.providerID}/${draft.model.id}` || prefix.agent !== draft.agent)
+      return false;
+    const index = draft.messages.findIndex((message) => message.id === prefix.anchor);
+    if (index < 0)
+      return false;
+    const tail = draft.messages.slice(index + 1);
+    draft.messages.splice(0, draft.messages.length, ...clonePreservingInstances(prefix.messages), ...tail);
+    draft.system.splice(0, draft.system.length, ...clonePreservingInstances(prefix.system));
+    draft.tools = clonePreservingInstances(prefix.tools);
+    return true;
+  }
+}
+
+// src/v2/hooks/hidden-terminal-error.ts
+function hiddenTerminalError(event) {
+  if (event.type === "session.execution.failed")
+    return event.data?.error;
+  if (event.type === "session.error")
+    return getSessionErrorInfo(event.data)?.error;
+  return;
+}
+
+// src/v2/hooks/lkg-system.ts
+import { createHash as createHash2 } from "node:crypto";
+function identity(slot) {
+  return createHash2("sha256").update(JSON.stringify({
+    capturedAt: slot.capturedAt,
+    captureSequence: slot.captureSequence,
+    rowVersion: slot.rowVersion,
+    modelKey: slot.modelKey,
+    providerKey: slot.providerKey,
+    inputIdSeq: slot.inputIdSeq,
+    inputContentDigests: slot.inputContentDigests
+  })).update(slot.jsonPrefix).digest("hex");
+}
+
+class V2LkgSystemReplay {
+  systems = new BoundedSessionMap(1000);
+  capture(sessionId, slot, input, served) {
+    this.systems.set(sessionId, {
+      slot: identity(slot),
+      input: JSON.stringify(input),
+      served: structuredClone(served)
+    });
+  }
+  restore(sessionId, slot, input, target) {
+    const saved = this.systems.get(sessionId);
+    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
+      return false;
+    target.splice(0, target.length, ...structuredClone(saved.served));
+    return true;
+  }
+}
+
+// src/v2/hooks/model-limit-cache.ts
+var warmStarted = false;
+function modelLimitCacheWarm() {
+  const state = getModelsDevCacheState();
+  return state.apiLoaded && state.apiCount > 0;
+}
+function catalogProvidersPayload(listed) {
+  const rows = Array.isArray(listed) ? listed : listed && typeof listed === "object" && Array.isArray(listed.data) ? listed.data : [];
+  const byProvider = new Map;
+  for (const row of rows) {
+    if (!row || typeof row !== "object")
+      continue;
+    const entry = row;
+    if (typeof entry.id !== "string" || typeof entry.providerID !== "string")
+      continue;
+    const models = byProvider.get(entry.providerID) ?? {};
+    models[entry.id] = entry;
+    byProvider.set(entry.providerID, models);
+  }
+  return [...byProvider.entries()].map(([id, models]) => ({ id, models }));
+}
+async function warmModelLimitCacheFromCatalog(context, options = {}) {
+  if (warmStarted)
+    return;
+  warmStarted = true;
+  try {
+    await refreshModelLimitsFromApi({
+      config: {
+        providers: async () => ({
+          data: {
+            providers: catalogProvidersPayload(await Promise.resolve(context.model.list()))
+          }
+        })
+      }
+    }, {
+      retries: options.retries ?? 3,
+      retryDelayMs: options.retryDelayMs ?? 1000
+    });
+  } catch (error) {
+    sessionLog("global", `v2 model-limit cache warm failed: ${getErrorMessage(error)}`);
+  } finally {
+    if (!modelLimitCacheWarm())
+      warmStarted = false;
+  }
+}
+
+// src/v2/hooks/refusal.ts
+class V2ContextRefusal extends Error {
+  constructor(message = "Context full — /ctx-flush or /clear to continue.", options) {
+    super(message, options);
+    this.name = "V2ContextRefusal";
+  }
+}
+var INTERRUPT_CONFIRMATION_TIMEOUT_MS = 2000;
+var systemTimers = {
+  setTimeout: (callback, ms) => setTimeout(callback, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+async function interruptBeforeProvider(session, sessionID, timers = systemTimers) {
+  let timer;
+  try {
+    const result = await Promise.race([
+      session.interrupt({ sessionID }),
+      new Promise((_, reject) => {
+        timer = timers.setTimeout(() => reject(new Error(`interrupt exceeded ${INTERRUPT_CONFIRMATION_TIMEOUT_MS} ms`)), INTERRUPT_CONFIRMATION_TIMEOUT_MS);
+      })
+    ]);
+    if (result.interrupted !== true)
+      throw new Error("interrupt arrived after the turn became idle");
+  } catch (cause) {
+    throw new V2ContextRefusal(undefined, { cause });
+  } finally {
+    if (timer !== undefined)
+      timers.clearTimeout(timer);
+  }
+}
+
+// src/v2/hooks/restore-rows.ts
+class RestoredRowCache {
+  capacity;
+  sessions = new Map;
+  constructor(capacity = 16) {
+    this.capacity = capacity;
+  }
+  rows(reader, sessionID, after, through) {
+    if (through <= after)
+      return [];
+    const kept = this.sessions.get(sessionID) ?? new Map;
+    const stamps = reader.spanRowStamps(sessionID, after, through);
+    const runs = [];
+    let previous = after;
+    let open;
+    for (const [seq, stamp] of stamps) {
+      if (kept.get(seq)?.stamp === stamp) {
+        open = undefined;
+      } else if (open) {
+        open.through = seq;
+      } else {
+        open = { after: previous, through: seq };
+        runs.push(open);
+      }
+      previous = seq;
+    }
+    const fresh = new Map;
+    for (const run of runs)
+      for (const row of readPages(reader, sessionID, run.after, run.through))
+        fresh.set(row.seq, row);
+    const next = new Map;
+    const rows = [];
+    for (const [seq, stamp] of stamps) {
+      const row = fresh.get(seq) ?? kept.get(seq)?.row;
+      if (!row)
+        continue;
+      next.set(seq, { stamp, row });
+      rows.push(row);
+    }
+    this.sessions.delete(sessionID);
+    this.sessions.set(sessionID, next);
+    while (this.sessions.size > this.capacity) {
+      const oldest = this.sessions.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.sessions.delete(oldest);
+    }
+    return structuredClone(rows);
+  }
+  forget(sessionID) {
+    this.sessions.delete(sessionID);
+  }
+  clear() {
+    this.sessions.clear();
+  }
+}
+function readPages(reader, sessionID, after, through) {
+  const rows = [];
+  let cursor = after;
+  while (cursor < through) {
+    const page = reader.page(sessionID, { after: cursor, through, limit: 100 });
+    rows.push(...page.rows);
+    if (page.rows.length < 100 || page.cursor === undefined)
+      break;
+    cursor = page.cursor;
+  }
+  return rows;
+}
+
+// src/v2/hooks/rpc-live-state.ts
+function createV2RpcLiveSessionState(overrides) {
+  return Object.assign(createLiveSessionState(), overrides);
+}
+
+// src/v2/hooks/rust-mode.ts
+var USER_TURN_TYPES = new Set(["user", "synthetic", "skill", "shell", "system"]);
+function resolveV2RustModeModuleClient(config, directory) {
+  if (config.transform_mode !== "rust")
+    return;
+  return createSubcModuleClient({
+    ...config.subc?.connection_file !== undefined ? { connectionFile: config.subc.connection_file } : {},
+    projectRoot: directory
+  });
+}
+function refusedStepStillCurrent(rows, refusedUserMessageId) {
+  const refused = rows.findIndex((row) => row.id === refusedUserMessageId);
+  if (refused < 0)
+    return false;
+  return !rows.slice(refused + 1).some((row) => USER_TURN_TYPES.has(row.type));
+}
+function createV2RustRefusalRecovery(args) {
+  return createRustRefusalRecovery({
+    ...args.pollIntervalMs !== undefined ? { pollIntervalMs: args.pollIntervalMs } : {},
+    ...args.maxDurationMs !== undefined ? { maxDurationMs: args.maxDurationMs } : {},
+    ...args.probeTimeoutMs !== undefined ? { probeTimeoutMs: args.probeTimeoutMs } : {},
+    moduleClient: args.moduleClient,
+    client: undefined,
+    deliverSynthetic: async ({ sessionId, text, beforeSend }) => {
+      if (!beforeSend())
+        return false;
+      await deliverSynthetic(args.context, sessionId, text);
+      return true;
+    },
+    isRefusedStepStillCurrent: (sessionId, refusedUserMessageId) => refusedStepStillCurrent(args.readRowsFrom(sessionId, refusedUserMessageId), refusedUserMessageId)
+  });
+}
+
+// src/v2/hooks/session-api-gate.ts
+var OPENCODE2_SESSION_API_NOTICE = "Magic Context is disabled: OpenCode 2.0.22 or newer is required (session.remove and session.compact). Upgrade OpenCode and restart.";
+function hasRequiredSessionAPI(session) {
+  const api = session;
+  return typeof api.remove === "function" && typeof api.compact === "function";
+}
+
+// src/v2/hooks/session-project-backfill.ts
+function runV2SessionProjectBackfill(db, openStoreReader, allowHomeProject = false) {
+  return runSessionProjectBackfill(db, (afterSessionId, limit) => {
+    const reader = openStoreReader();
+    try {
+      return reader.sessionDirectoryPage(afterSessionId, limit);
+    } finally {
+      reader.close();
+    }
+  }, { leaseKey: `${getHarness()}:session-projects-creation-v2`, allowHomeProject });
+}
+
+// src/v2/hooks/storage-gate.ts
+var V2_STORAGE_REOPEN_INTERVAL_MS = 5000;
+function createV2StorageGate(options = {}) {
+  const open = options.open ?? (async () => {
+    const opened = await openDatabaseAsync({ busyTimeoutMs: 0 });
+    opened?.exec(`PRAGMA busy_timeout=${BOOT_SQLITE_BUSY_TIMEOUT_MS}`);
+    return opened;
+  });
+  const now = options.now ?? (() => Date.now());
+  const interval = options.reopenIntervalMs ?? V2_STORAGE_REOPEN_INTERVAL_MS;
+  let db;
+  let failure = null;
+  let failureKey = null;
+  let lastAttemptAt;
+  let pending;
+  const attempt = async () => {
+    let next;
+    try {
+      const opened = await open();
+      if (opened && isDatabasePersisted(opened)) {
+        db = opened;
+        const recovered = failure !== null;
+        failure = null;
+        failureKey = null;
+        if (recovered)
+          options.onRecovered?.(opened);
+        return db;
+      }
+      next = describeStorageUnavailability(getDatabasePersistenceError(opened) ?? "context storage is not durable");
+    } catch (error) {
+      next = describeStorageUnavailability(getErrorMessage(error));
+    }
+    const key = JSON.stringify(next);
+    failure = next;
+    if (key !== failureKey) {
+      failureKey = key;
+      options.onUnavailable?.(next);
+    }
+    return;
+  };
+  const probe = () => {
+    if (db)
+      return Promise.resolve(db);
+    if (pending)
+      return pending;
+    if (lastAttemptAt !== undefined && now() - lastAttemptAt < interval)
+      return Promise.resolve(undefined);
+    pending = Promise.resolve().then(attempt).finally(() => {
+      lastAttemptAt = now();
+      pending = undefined;
+    });
+    return pending;
+  };
+  return {
+    current: () => db,
+    reason: () => failure,
+    probe,
+    require: () => {
+      if (db)
+        return db;
+      probe();
+      throw createFailClosedBlockingError(failure ?? { kind: "storage_failure", cause: "context storage is not durable" });
+    }
+  };
+}
+async function probeV2StorageAtBoot(storage, timeoutMs = 15000) {
+  const deadline = startBootDeadline(timeoutMs);
+  try {
+    return await Promise.race([storage.probe(), deadline.expired.then(() => {
+      return;
+    })]);
+  } finally {
+    deadline.cancel();
+  }
+}
+
+// src/v2/hooks/store.ts
+var rawMessageTypes = new Set(RAW_MESSAGE_TYPES);
+var isRawRow = (row) => rawMessageTypes.has(row.type);
+var NO_MODEL = { providerID: "", id: "" };
+function hostServesRowById(row) {
+  return isRawRow(row) && restoreRow(row, NO_MODEL).some((message) => message.id === row.id);
+}
+function projectRawMessages(rows, ordinalFor) {
+  return rows.filter(isRawRow).map((row, index) => {
+    const message = {
+      id: row.id,
+      ordinal: ordinalFor(row, index),
+      role: row.type === "assistant" ? "assistant" : "user",
+      createdAt: row.time_created ?? row.data.time?.created,
+      parts: row.type === "assistant" ? (row.data.content ?? []).map((part) => {
+        if (part.type !== "tool")
+          return { ...part };
+        const state = part.state;
+        const content = state.content;
+        return {
+          type: "tool",
+          tool: part.name,
+          callID: part.id,
+          state: {
+            ...state,
+            output: state.status === "error" ? toolStateContent(state) : content?.filter((p) => p.type === "text").map((p) => p.text).join(`
+`) ?? ""
+          }
+        };
+      }) : [{ type: "text", text: row.data.text ?? "" }]
+    };
+    Object.defineProperty(message, "storeType", { value: row.type, enumerable: false });
+    if (!hostServesRowById(row))
+      markHostUnservedRow(message);
+    return message;
+  });
+}
+function rawMessages(rows, history = rows) {
+  const ordinals = new Map(history.filter(isRawRow).map((row, index) => [row.id, index + 1]));
+  return projectRawMessages(rows, (row) => {
+    return ordinals.get(row.id) ?? 0;
+  });
+}
+function rawMessagePage(rows, afterOrdinal) {
+  return projectRawMessages(rows, (_row, index) => afterOrdinal + index + 1);
+}
+var SERVED_BOUNDARY_PAGE = 50;
+function servedBoundaryRow(reader, sessionID, messageID) {
+  const boundary = reader.messageById(sessionID, messageID);
+  if (!boundary)
+    return null;
+  if (hostServesRowById(boundary))
+    return boundary;
+  let through = boundary.seq - 1;
+  for (;; ) {
+    const rows = reader.rawRowsThrough(sessionID, through, SERVED_BOUNDARY_PAGE);
+    const served = rows.find(hostServesRowById);
+    if (served)
+      return served;
+    const oldest = rows.at(-1);
+    if (rows.length < SERVED_BOUNDARY_PAGE || !oldest)
+      return null;
+    through = oldest.seq - 1;
+  }
+}
+function resolveV2BoundaryUserMessage(reader, sessionID, endMessageID) {
+  const end = reader.messageById(sessionID, endMessageID);
+  if (!end || !isRawRow(end))
+    return null;
+  let through = end.seq;
+  for (;; ) {
+    const rows = reader.rawRowsThrough(sessionID, through, SERVED_BOUNDARY_PAGE);
+    const user = rows.find((row) => row.type !== "assistant");
+    if (user)
+      return rawMessagePage([user], 0)[0] ?? null;
+    const oldest = rows.at(-1);
+    if (rows.length < SERVED_BOUNDARY_PAGE || !oldest)
+      return null;
+    through = oldest.seq - 1;
+  }
+}
+function readAllV2RawMessagesForConversion(openReader, sessionID) {
+  const reader = openReader();
+  try {
+    return rawMessages(reader.history(sessionID));
+  } finally {
+    reader.close();
+  }
+}
+var CONVERSION_PAGE_ROWS = 1000;
+function* readV2RawMessagePagesForConversion(openReader, sessionID, pageRows = CONVERSION_PAGE_ROWS) {
+  const reader = openReader();
+  try {
+    let after = -1;
+    let ordinal = 0;
+    for (;; ) {
+      const page = reader.page(sessionID, { after, limit: pageRows });
+      const messages = rawMessagePage(page.rows, ordinal);
+      ordinal += messages.length;
+      if (messages.length > 0)
+        yield messages;
+      if (page.rows.length < pageRows || page.cursor === undefined)
+        return;
+      after = page.cursor;
+    }
+  } finally {
+    reader.close();
+  }
+}
+function createV2RawMessageReader(openReader) {
+  const servedBoundaryCache = new Map;
+  return {
+    readPage: (sessionID, afterOrdinal, limit, finalWatermark, after) => {
+      const reader = openReader();
+      try {
+        return rawMessagePage(reader.messagePage(sessionID, afterOrdinal, limit, finalWatermark, after), afterOrdinal);
+      } finally {
+        reader.close();
+      }
+    },
+    findById: (sessionID, messageID) => {
+      const reader = openReader();
+      try {
+        const ordinal = reader.messageOrdinalById(sessionID, messageID);
+        const row = reader.messageById(sessionID, messageID);
+        if (ordinal === null || row === null)
+          return null;
+        return rawMessagePage([row], ordinal - 1)[0] ?? null;
+      } finally {
+        reader.close();
+      }
+    },
+    findPartsById: (sessionID, messageID) => {
+      const reader = openReader();
+      try {
+        const row = reader.messageById(sessionID, messageID);
+        return row ? rawMessagePage([row], 0)[0] ?? null : null;
+      } finally {
+        reader.close();
+      }
+    },
+    hasById: (sessionID, messageID) => {
+      const reader = openReader();
+      try {
+        return reader.messageExistsById(sessionID, messageID);
+      } finally {
+        reader.close();
+      }
+    },
+    ordinalOf: (sessionID, messageID) => {
+      const reader = openReader();
+      try {
+        return reader.messageOrdinalById(sessionID, messageID);
+      } finally {
+        reader.close();
+      }
+    },
+    ordinalMapForRange: (sessionID, fromOrdinal, toOrdinal) => {
+      const reader = openReader();
+      try {
+        return reader.messageIdOrdinals(sessionID, fromOrdinal, toOrdinal);
+      } finally {
+        reader.close();
+      }
+    },
+    readOrdinalPage: (sessionID, after, limit) => {
+      const reader = openReader();
+      try {
+        return reader.messageOrdinalPage(sessionID, after, limit);
+      } finally {
+        reader.close();
+      }
+    },
+    getCount: (sessionID) => {
+      const reader = openReader();
+      try {
+        return reader.messageCount(sessionID);
+      } finally {
+        reader.close();
+      }
+    },
+    getStoredCount: (sessionID) => {
+      const reader = openReader();
+      try {
+        return reader.storedMessageCount(sessionID);
+      } finally {
+        reader.close();
+      }
+    },
+    servedBoundaryIdOf: (sessionID, messageID) => {
+      const key = `${sessionID}\x00${messageID}`;
+      if (servedBoundaryCache.has(key))
+        return servedBoundaryCache.get(key) ?? null;
+      const reader = openReader();
+      try {
+        const served = servedBoundaryRow(reader, sessionID, messageID)?.id ?? null;
+        if (servedBoundaryCache.size >= 1000)
+          servedBoundaryCache.clear();
+        if (served !== null)
+          servedBoundaryCache.set(key, served);
+        return served;
+      } finally {
+        reader.close();
+      }
+    }
+  };
+}
+function createV2RawMessageProvider(reader, sessionID) {
+  return {
+    readMessagePage: (afterOrdinal, limit, finalWatermark, after) => reader.readPage(sessionID, afterOrdinal, limit, finalWatermark, after),
+    readMessageById: (messageID) => reader.findById(sessionID, messageID),
+    readMessagePartsById: (messageID) => reader.findPartsById(sessionID, messageID),
+    hasMessageById: (messageID) => reader.hasById(sessionID, messageID),
+    readMessageOrdinalById: (messageID) => reader.ordinalOf(sessionID, messageID),
+    readMessageIdOrdinalsForRange: (fromOrdinal, toOrdinal) => reader.ordinalMapForRange(sessionID, fromOrdinal, toOrdinal),
+    readMessageOrdinalPage: (after, limit) => reader.readOrdinalPage(sessionID, after, limit),
+    getMessageCount: () => reader.getCount(sessionID),
+    getStoredMessageCount: () => reader.getStoredCount(sessionID),
+    ...reader.servedBoundaryIdOf ? {
+      readServedBoundaryId: (messageID) => reader.servedBoundaryIdOf?.(sessionID, messageID) ?? null
+    } : {}
+  };
+}
+
+// src/v2/hooks/tools.ts
+import { tool } from "@opencode-ai/plugin";
+async function registerTools(context, db, config, rustToolBackends, isInternalChild) {
+  const compaction = isCompactionEnabled(config);
+  setCtxReduceRegisteredGlobally(compaction);
+  const project = {
+    db,
+    resolveProjectPath: (directory) => resolveProjectIdentityForSession(directory, config.allow_home_project),
+    ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
+  };
+  const definitions = {
+    ...compaction ? createCtxReduceTools({
+      db,
+      protectedTools: config.protected_tools,
+      getProtectionWindow: (sessionID) => getProtectionWindowForSession(db, sessionID, getObservedEpochFloor(db, sessionID)),
+      ...rustToolBackends ? { rustToolBackends } : {}
+    }) : {},
+    ...createCtxExpandTools({ db, expandTools: config.historian?.expand_tools }),
+    ...createCtxNoteTools({
+      ...project,
+      dreamerEnabled: isDreamerRunnable(config),
+      ...rustToolBackends ? { rustToolBackends } : {}
+    }),
+    ...createCtxSearchTools(project),
+    ...config.memory.enabled ? {
+      ...createCtxMemoryTools({
+        ...project,
+        ...rustToolBackends ? { rustToolBackends } : {}
+      }),
+      ...createCtxMemoryListTools({
+        ...project,
+        ...rustToolBackends ? { rustToolBackends } : {}
+      })
+    } : {}
+  };
+  const controller = new AbortController;
+  await context.tool.transform?.((editor) => {
+    for (const [name, definition] of Object.entries(definitions)) {
+      editor.add?.({
+        name,
+        description: definition.description,
+        input: tool.schema.toJSONSchema(tool.schema.object(definition.args)),
+        options: { codemode: false },
+        async execute(input, call) {
+          const refusal = subagentToolRefusal(db, name, call.sessionID, isInternalChild);
+          if (refusal)
+            return { content: refusal };
+          if (name === "ctx_memory" || name === "ctx_note" || name === "ctx_reduce")
+            await withAsyncPrivilegedWriter(db, () => {
+              return;
+            });
+          const parsedInput = tool.schema.object(definition.args).passthrough().safeParse(input);
+          const result = await definition.execute(parsedInput.success ? parsedInput.data : input, {
+            sessionID: call.sessionID,
+            messageID: call.messageID,
+            agent: call.agent,
+            directory: context.location.directory,
+            worktree: context.location.directory,
+            abort: controller.signal,
+            metadata: (value) => {
+              call.progress(value);
+            },
+            ask: async () => {
+              throw new Error("This tool requires an unavailable permission request");
+            }
+          });
+          return { content: typeof result === "string" ? result : result.output };
+        }
+      });
+    }
+  });
+  return { dispose: () => controller.abort() };
+}
+
+// src/v2/hooks/usage-reading.ts
+function usageReadingMatchesDraft(reading, draftModel) {
+  return reading.modelKey === undefined || reading.modelKey === `${draftModel.providerID}/${draftModel.id}`;
+}
+function resolveUsageReading(input) {
+  const { tokens } = input;
+  const successfulCompletion = isSuccessfulProviderCompletion({
+    completedAt: input.completed,
+    finish: input.finish,
+    error: input.error
+  });
+  if (!tokens && !successfulCompletion)
+    return;
+  const numeric = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+  const rowProviderID = typeof input.rowModel?.providerID === "string" ? input.rowModel.providerID : undefined;
+  const rowModelID = typeof input.rowModel?.id === "string" ? input.rowModel.id : undefined;
+  const measuredProviderID = rowProviderID ?? input.draftModel.providerID;
+  const measuredModelID = rowModelID ?? input.draftModel.id;
+  const inputTokens = numeric(tokens?.input) + numeric(tokens?.cache?.read) + numeric(tokens?.cache?.write);
+  const limit = input.limitFor(measuredProviderID, measuredModelID);
+  if ((!Number.isFinite(limit) || limit <= 0) && !successfulCompletion)
+    return;
+  const sameModel = measuredProviderID === input.draftModel.providerID && measuredModelID === input.draftModel.id;
+  const draftLimit = sameModel ? limit : input.limitFor(input.draftModel.providerID, input.draftModel.id);
+  return {
+    inputTokens,
+    limit,
+    admissionLimit: Number.isFinite(draftLimit) && draftLimit > 0 ? draftLimit : limit,
+    ...rowProviderID !== undefined && rowModelID !== undefined ? { modelKey: `${measuredProviderID}/${measuredModelID}` } : {},
+    ...typeof input.completed === "number" && Number.isFinite(input.completed) ? { completed: input.completed } : {},
+    ...input.finish !== undefined ? { finish: input.finish } : {},
+    ...input.error !== undefined ? { error: input.error } : {}
+  };
+}
+
+// src/v2/hooks/usage-persist.ts
+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}`);
+    return;
+  }
+  const draftModelKey = `${draftModel.providerID}/${draftModel.id}`;
+  const readingMatchesDraft = usageReadingMatchesDraft(reading, draftModel);
+  const completion = {
+    completedAt: reading.completed,
+    finish: reading.finish,
+    error: reading.error
+  };
+  const served = !providerResponseFailed(completion) && (reading.inputTokens > 0 || isSuccessfulProviderCompletion(completion));
+  const responseTime = served && reading.completed;
+  if (reading.inputTokens <= 0 || !Number.isFinite(reading.limit) || reading.limit <= 0) {
+    if (responseTime)
+      updateSessionMeta(db, sessionID, { lastResponseTime: responseTime });
+    return;
+  }
+  const percentage = reading.inputTokens / reading.limit * 100;
+  const updates = {
+    lastContextPercentage: percentage,
+    lastInputTokens: reading.inputTokens,
+    lastUsageContextLimit: reading.limit,
+    lastObservedModelKey: reading.modelKey ?? draftModelKey
+  };
+  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"}`);
+  if (readingMatchesDraft) {
+    args.contextUsageMap.set(sessionID, {
+      usage: { inputTokens: reading.inputTokens, percentage },
+      hasUsageTokens: true,
+      updatedAt: Date.now()
+    });
+  } else {
+    args.contextUsageMap.delete(sessionID);
+  }
+}
+
+// src/v2/hooks/context.ts
+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);
+}
+function checkHistoryBoundary(db, reader, sessionID) {
+  try {
+    const storeHasSession = reader.earliestSequence(sessionID) !== undefined;
+    return repairMissingHistoryBoundary({
+      db,
+      sessionId: sessionID,
+      isInHostStore: (messageId) => storeHasSession ? reader.sequenceForId(sessionID, messageId) !== undefined : null
+    });
+  } catch (error) {
+    sessionLog(sessionID, "history boundary check failed; continuing without repair", error);
+    return;
+  }
+}
+async function cacheV2SessionDirectory(session, sessionID, directories) {
+  if (directories.has(sessionID))
+    return;
+  try {
+    const directory = (await session.get({ sessionID }))?.location?.directory;
+    if (typeof directory === "string" && directory.length > 0) {
+      directories.set(sessionID, directory);
+    }
+  } catch (error) {
+    sessionLog(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))}` : ""}`);
+  return interruptBeforeProvider(session, sessionID);
+}
+function createHostSeams(context, readAllForConversion, reconciliationSource, liveModels) {
+  return {
+    hostRawMessages: readAllForConversion,
+    hostMessageReconciliationSource: reconciliationSource,
+    hostProtectedTailBoundary: (args) => resolveOpenCodeProtectedTailBoundary({
+      ...args,
+      cacheNamespace: `opencode2:${args.sessionId}`
+    }),
+    hostModelFallback: (sessionID) => liveModels.get(sessionID) ?? null,
+    getModelKey: (sessionID) => {
+      const model = liveModels.get(sessionID);
+      return resolveModelKey(model?.providerID, model?.modelID);
+    },
+    hostRefusalNotice: async (_client, sessionID, message) => {
+      pushNotification2("toast", { message, variant: "error" }, sessionID);
+      await deliverSynthetic(context, sessionID, message);
+    },
+    hostRefuse: (_client, sessionID) => refuseBeforeProvider(context.session, sessionID, "transform-fail-closed")
+  };
+}
+function createV2ThresholdDeps(config) {
+  return {
+    scheduler: createScheduler({
+      executeThresholdPercentage: config.execute_threshold_percentage,
+      executeThresholdTokens: config.execute_threshold_tokens
+    }),
+    executeThresholdPercentage: config.execute_threshold_percentage,
+    executeThresholdTokens: config.execute_threshold_tokens
+  };
+}
+function toolResultText2(result) {
+  const content = result?.content ?? result?.output;
+  if (typeof content === "string")
+    return content;
+  if (content && typeof content === "object" && !Array.isArray(content)) {
+    const record = content;
+    if (typeof record.text === "string")
+      return record.text;
+    if (typeof record.value === "string")
+      return record.value;
+    return "";
+  }
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => {
+    if (typeof part === "string")
+      return part;
+    if (!part || typeof part !== "object")
+      return "";
+    const record = part;
+    if (typeof record.text === "string")
+      return record.text;
+    if (typeof record.value === "string")
+      return record.value;
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+function reportPreProviderRefusal(sessionID, error) {
+  sessionLog(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 : [];
+  const models = rows.flatMap((row) => {
+    if (!row || typeof row !== "object")
+      return [];
+    const model = row;
+    if (typeof model.id !== "string" || typeof model.providerID !== "string")
+      return [];
+    const contextLimit = model.limit?.context;
+    if (typeof contextLimit !== "number" || !Number.isFinite(contextLimit))
+      return [];
+    return [
+      {
+        id: model.id,
+        providerID: model.providerID,
+        limit: { ...model.limit, context: contextLimit }
+      }
+    ];
+  });
+  const draftContextLimit = draftModel?.limit?.context;
+  if (draftModel && typeof draftContextLimit === "number" && Number.isFinite(draftContextLimit) && draftContextLimit > 0) {
+    const key = `${draftModel.providerID}/${draftModel.id}`;
+    const byKey = new Map(models.map((model) => [`${model.providerID}/${model.id}`, model]));
+    byKey.set(key, {
+      id: draftModel.id,
+      providerID: draftModel.providerID,
+      limit: { ...draftModel.limit, context: draftContextLimit }
+    });
+    return [...byKey.values()];
+  }
+  return models;
+}
+function removeDreamerOnlyTools(draft) {
+  if (draft.tools)
+    delete draft.tools.ctx_memory_list;
+}
+function applyV2PromptSurfaceTools(draft, runtime, config) {
+  if (!draft.tools)
+    return;
+  const modelKey = `${draft.model.providerID}/${draft.model.id}`;
+  const registration = runtime.resolveRegistration(config, modelKey);
+  for (const id of ACTIVE_TOOL_IDS) {
+    const tool = draft.tools[id];
+    if (!tool)
+      continue;
+    tool.description = registration.descriptionFor(id, tool.description);
+    applyJsonSchemaParameterDescriptions(id, tool.input, registration.preset);
+  }
+}
+function recordV2ToolDefinitions(draft) {
+  if (!draft.tools)
+    return;
+  for (const [id, tool] of Object.entries(draft.tools)) {
+    if (!tool)
+      continue;
+    recordToolParameters(id, tool.input);
+    recordToolDefinition(draft.model.providerID, draft.model.id, draft.agent, id, typeof tool.description === "string" ? tool.description : "", tool.input);
+  }
+}
+async function applyV2SystemPrompt(systemPrompt, draft) {
+  resolveCtxReduceAvailabilityFromMessages(draft.sessionID, draft.messages.map((message) => ({
+    info: {
+      role: message.role,
+      tools: { ctx_reduce: Object.hasOwn(draft.tools, "ctx_reduce") }
+    }
+  })));
+  const system = { system: draft.system.map((part) => String(part.text ?? "")) };
+  await systemPrompt.handler({
+    sessionID: draft.sessionID,
+    model: { providerID: draft.model.providerID, modelID: draft.model.id }
+  }, system);
+  const originals = [...draft.system];
+  draft.system.splice(0, draft.system.length, ...system.system.map((text, index) => ({
+    ...originals[index],
+    type: "text",
+    text
+  })));
+}
+async function registerContext(context) {
+  const directory = context.location.directory;
+  const config = loadPluginConfigDetailed(directory).config;
+  setHomeProjectPermission(config.allow_home_project);
+  if (!config.enabled)
+    return;
+  const nativeRemove = nativeSessionRemove(context.session);
+  if (!hasRequiredSessionAPI(context.session) || !nativeRemove) {
+    const message = OPENCODE2_SESSION_API_NOTICE;
+    console.warn(`[magic-context] v2 host API unavailable: ${message}`);
+    log(`[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));
+      }
+      await refuseBeforeProvider(context.session, draft.sessionID, "unsupported-session-api");
+    };
+    await context.session.hook("context", refuseUnsupportedHost);
+    await context.session.hook("compaction", async (draft) => {
+      draft.result = { summary: message };
+      await refuseUnsupportedHost(draft);
+    });
+    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,
+    hostGeneration: "v2"
+  });
+  if (conflicts.hasConflict) {
+    console.warn(`[magic-context] v2 setup disabled by conflicting context hooks: ${conflicts.reasons.join("; ")}`);
+    return;
+  }
+  const folds = new FoldOwner(context.storage);
+  setOutputReserveConfig(config.output_reserve);
+  const queriedModels = new Set;
+  const rawLimits = new Map;
+  const hiddenSessionErrors = new Map;
+  const liveModels = new Map;
+  const promptSurfaceRuntime = createPromptSurfaceRuntime({
+    harness: "opencode2",
+    directory,
+    warn: (message) => log(`[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}`);
+    }
+  });
+  let db = await probeV2StorageAtBoot(storage);
+  const storageOpenedAtBoot = db !== undefined;
+  let legacyCleanupStarted = false;
+  const cleanupLegacyOnce = async (database) => {
+    if (legacyCleanupStarted)
+      return;
+    legacyCleanupStarted = true;
+    await cleanupLegacyHiddenChildren(database, nativeRemove, log);
+  };
+  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)));
+  };
+  const noticeStorageRefusal = (sessionID, reason) => {
+    const message = formatStorageRefusalNotice(reason);
+    pushNotification2("toast", { message, variant: "error" }, sessionID);
+    if (storageNoticeBySession.get(sessionID) === message)
+      return;
+    storageNoticeBySession.set(sessionID, message);
+    storeStorageNotice(sessionID, message, "refusal");
+  };
+  const rustModeModuleClient = resolveV2RustModeModuleClient(config, directory);
+  const rustMemorySyncRequestedSessions = new Set;
+  const moduleToolBackends = db && isDatabasePersisted(db) ? createModuleToolBackends({
+    db,
+    moduleClient: rustModeModuleClient,
+    directory,
+    memorySyncRequestedSessions: rustMemorySyncRequestedSessions
+  }) : undefined;
+  const hiddenChildHook = new HiddenChildHook;
+  const tools = db && isDatabasePersisted(db) ? await registerTools(context, db, config, moduleToolBackends?.backends, (id) => hiddenChildHook.owns(id)) : undefined;
+  const usage = new Map;
+  const generateReplay = new V2GenerateReplay;
+  await context.session.hook("http.response", async (draft) => {
+    if (!db || draft.kind !== "primary" || draft.response.ok)
+      return;
+    const detection = detectOverflow(await draft.response.clone().text());
+    if (!detection.isOverflow)
+      return;
+    const modelKey = `${draft.model.providerID}/${draft.model.id}`;
+    if (compactionOff) {
+      if (detection.reportedLimit)
+        recordDetectedContextLimit(db, draft.sessionID, detection.reportedLimit, modelKey, detection.reportedLimitProvenance);
+    } else {
+      recordOverflowDetected(db, draft.sessionID, detection.reportedLimit, modelKey, "provider_overflow", detection.reportedLimitProvenance, detection.reportedInputTokens);
+      if (detection.reportedInputTokens) {
+        const provenLimit = getOverflowState(db, draft.sessionID, modelKey).detectedContextLimit;
+        usage.set(draft.sessionID, {
+          usage: {
+            inputTokens: detection.reportedInputTokens,
+            percentage: provenLimit > 0 ? detection.reportedInputTokens / provenLimit * 100 : 100
+          },
+          hasUsageTokens: true,
+          updatedAt: Date.now()
+        });
+      }
+    }
+  });
+  await registerHiddenChildAgents(context.agent);
+  let hiddenAgentsReady;
+  const readerPool = new V2StoreReaderPool;
+  const openStoreReader = () => readerPool.open(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
+  const createHiddenExecutor = async (database) => {
+    await cleanupLegacyOnce(database);
+    return createV2HiddenCompletionExecutor({
+      ...context.session,
+      get: async (input) => {
+        const session = await context.session.get(input);
+        const error = hiddenSessionErrors.get(input.sessionID);
+        return error === undefined ? session : { ...session, error };
+      },
+      terminalError: async (input) => {
+        const deadline = Date.now() + HIDDEN_SESSION_ERROR_GRACE_MS;
+        do {
+          const error = hiddenSessionErrors.get(input.sessionID);
+          if (error !== undefined)
+            return error;
+          await new Promise((resolve) => setTimeout(resolve, 5));
+        } while (Date.now() < deadline);
+        return;
+      },
+      prompt: async (input) => {
+        hiddenSessionErrors.delete(input.sessionID);
+        return context.session.prompt(input);
+      },
+      removeSession: nativeRemove
+    }, {
+      db: database,
+      projectIdentity: resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
+      directory,
+      hook: hiddenChildHook,
+      keepSubagents: config.keep_subagents === true,
+      ensureAgent: () => hiddenAgentsReady ??= context.agent.reload(),
+      modelCatalog: () => Promise.resolve(context.model.list()),
+      openReader: openStoreReader
+    });
+  };
+  const dreamerAtBoot = config.dreamer;
+  const startDreamer = (executor) => {
+    const projectIdentity = resolveProjectIdentityForSession(directory, config.allow_home_project);
+    if (!projectIdentity || !dreamerAtBoot || dreamerAtBoot.disable)
+      return;
+    const cappedExecutor = withLiveDreamerOutputCap(executor, config, () => liveConfigReader.poll().effective);
+    const trigger = startDreamTrigger(context, {
+      config: dreamerAtBoot,
+      sample: () => {
+        const current = dreamerRunConfig(config, liveConfigReader.poll().effective);
+        return { config: current.dreamer ?? dreamerAtBoot, mural: current.mural };
+      },
+      executor: cappedExecutor,
+      projectIdentity: () => resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
+      projectMemoryEnabled: config.memory.enabled,
+      language: config.language,
+      mural: config.mural
+    });
+    const timer = registerV2DreamScheduleTimer({
+      directory,
+      projectIdentity,
+      config,
+      dreamer: dreamerAtBoot,
+      liveConfig: () => liveConfigReader.poll().effective,
+      executor: cappedExecutor,
+      openReader: openStoreReader
+    });
+    return {
+      async dispose() {
+        await Promise.all([trigger.dispose(), timer.dispose()]);
+      }
+    };
+  };
+  let hiddenCompletionExecutor = db && isDatabasePersisted(db) && resolveProjectIdentityForSession(directory, config.allow_home_project) ? await createHiddenExecutor(db) : undefined;
+  let dreamTrigger = hiddenCompletionExecutor ? startDreamer(hiddenCompletionExecutor) : undefined;
+  const lateHiddenExecutor = createLateHiddenExecutor(() => hiddenCompletionExecutor);
+  let hiddenWorkRecovery;
+  const recoverHiddenWork = (database) => !resolveProjectIdentityForSession(directory, config.allow_home_project) ? Promise.resolve(false) : hiddenWorkRecovery ??= (async () => {
+    try {
+      hiddenCompletionExecutor ??= await createHiddenExecutor(database);
+      dreamTrigger ??= startDreamer(hiddenCompletionExecutor);
+      return true;
+    } catch (error) {
+      log("[magic-context] v2 historian and dreamer could not start after recovery:", error);
+      return false;
+    }
+  })();
+  const sampleHistorian = () => {
+    const fresh = historianRunConfig(config, liveConfigReader.poll().effective);
+    const models = resolveHistorianModel2(fresh, "opencode");
+    return {
+      model: models.primary,
+      fallbackModels: models.fallbacks,
+      contextLimit: resolveKnownHistorianContextLimit2(models.primary?.model),
+      maxOutputTokens: fresh.historian?.maxTokens,
+      timeoutMs: fresh.historian_timeout_ms,
+      twoPass: fresh.historian?.two_pass === true,
+      expandTools: fresh.historian?.expand_tools,
+      autoPromote: fresh.memory?.auto_promote ?? true,
+      userMemoriesEnabled: userMemoryCollectionEnabled2(fresh.dreamer),
+      commitClusterTrigger: fresh.commit_cluster_trigger,
+      chunkTokens: deriveHistorianChunkTokens2(resolveHistorianContextLimit2(models.primary?.model))
+    };
+  };
+  const historianModels = resolveHistorianModel2(config, "opencode");
+  const channel1 = new Map;
+  const variants = new Map;
+  const agents = new Map;
+  const sessionDirectories = new Map;
+  const historyRefreshSessions = new Set;
+  const pendingMaterializationSessions = new Set;
+  const lastHeuristicsTurnId = new Map;
+  const restoredRows = new RestoredRowCache;
+  const rawProviders = new Map;
+  let passDuties;
+  let toolDuties;
+  const droppedInputGuard = createDroppedInputGuard();
+  await context.tool.hook("execute.before", (draft) => assertExecutableToolInput(droppedInputGuard, {
+    sessionID: draft.sessionID,
+    toolName: draft.tool,
+    input: draft.input
+  }));
+  await context.tool.hook("execute.after", async (draft) => {
+    if (!db)
+      return;
+    if (draft.status && draft.status !== "completed")
+      return;
+    try {
+      toolDuties ??= createToolExecuteAfterHook({ db, channel1StateBySession: channel1 });
+      const text = toolResultText2(draft.result);
+      const output = { output: text };
+      await toolDuties({ ...draft, args: draft.input }, output);
+      if (draft.result && output.output !== text) {
+        const content = draft.result.content;
+        if (typeof content === "string")
+          draft.result.content = output.output;
+        else if (Array.isArray(content) && output.output.startsWith(text))
+          content.push({ type: "text", text: output.output.slice(text.length) });
+      }
+      const baseline = channel1.get(draft.sessionID);
+      await deliverPendingChannel2(context, db, draft.sessionID, baseline);
+    } catch (error) {
+      log("[magic-context] v2 Channel 2 delivery deferred", error);
+    }
+  });
+  const pagedRead = createV2RawMessageReader(openStoreReader);
+  const prepareHistorySession = (sessionID) => {
+    if (!rawProviders.has(sessionID))
+      rawProviders.set(sessionID, setBoundedRawMessageProvider2(sessionID, createV2RawMessageProvider(pagedRead, sessionID)));
+  };
+  if (db && isDatabasePersisted(db)) {
+    const backfillDb = db;
+    scheduleAfterBootQuiet(() => {
+      runV2SessionProjectBackfill(backfillDb, openStoreReader, config.allow_home_project).then(() => backfillSessionActivity(backfillDb, "opencode", (sessionId) => {
+        const reader = openStoreReader();
+        try {
+          return reader.latestMessageTime(sessionId);
+        } finally {
+          reader.close();
+        }
+      })).catch((error) => log("[session-project-backfill] OpenCode 2 backfill failed:", error));
+    });
+  }
+  const readAllForConversion = (sessionID) => readAllV2RawMessagesForConversion(openStoreReader, sessionID);
+  const readRowsFrom = (sessionID, messageID) => {
+    const reader = openStoreReader();
+    try {
+      const seq = reader.sequenceForId(sessionID, messageID);
+      if (seq === undefined)
+        return [];
+      return reader.range(sessionID, seq - 1, reader.latestSequence(sessionID));
+    } finally {
+      reader.close();
+    }
+  };
+  const rustRefusalRecovery = rustModeModuleClient ? createV2RustRefusalRecovery({
+    context,
+    moduleClient: rustModeModuleClient,
+    readRowsFrom
+  }) : undefined;
+  const lkgSystems = new V2LkgSystemReplay;
+  let transform;
+  let systemPrompt;
+  const systemPromptRefreshSessions = new Set;
+  const tagger = createTagger();
+  const deletedSessions = new DeletedSessionTombstones;
+  const forkSeedSettled = new Set;
+  const inheritForkState = (database, sessionID) => {
+    if (forkSeedSettled.has(sessionID))
+      return;
+    if (sessionHasMagicContextState(database, sessionID)) {
+      forkSeedSettled.add(sessionID);
+      return;
+    }
+    let reader;
+    try {
+      reader = openStoreReader();
+      const outcome = seedV2ForkFromParent({
+        db: database,
+        store: reader,
+        sessionId: sessionID
+      });
+      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}`);
+      } else if (outcome.kind === "parent-missing") {
+        sessionLog(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`);
+      }
+    } catch (error) {
+      if (isTransientSqliteError(error))
+        throw error;
+      forkSeedSettled.add(sessionID);
+      sessionLog(sessionID, "v2 fork inheritance failed; continuing without it:", error);
+    } finally {
+      reader?.close();
+    }
+  };
+  const latestLkgResponseIds = new BoundedSessionMap(1000);
+  const recordUsage = async (draft) => {
+    let unsafe = false;
+    try {
+      await storage.probe();
+      db = storage.require();
+      getOrCreateSessionMeta(db, draft.sessionID);
+      const reader = openStoreReader();
+      try {
+        const latest = reader.latestAssistant(draft.sessionID);
+        latestLkgResponseIds.set(draft.sessionID, latest?.id);
+        if (latest)
+          noteLkgProviderResponse({
+            sessionId: draft.sessionID,
+            responseId: latest.id,
+            modelKey: latest.data.model?.providerID && latest.data.model?.id ? `${latest.data.model.providerID}/${latest.data.model.id}` : undefined,
+            inputTokens: lkgProviderInputTotal(latest.data.tokens),
+            completedAt: latest.data.time?.completed,
+            createdAt: latest.data.time?.created ?? latest.time_created,
+            finish: latest.data.finish,
+            error: latest.data.error,
+            v2: true
+          });
+        const draftModelKey = `${draft.model.providerID}/${draft.model.id}`;
+        if (!queriedModels.has(draftModelKey)) {
+          const catalog = await Promise.resolve(context.model.list());
+          const providers = new Map;
+          for (const model of catalogModels(catalog, draft.model)) {
+            rawLimits.set(`${model.providerID}/${model.id}`, model.limit);
+            const provider = providers.get(model.providerID) ?? {
+              id: model.providerID,
+              models: {}
+            };
+            provider.models[model.id] = { limit: model.limit };
+            providers.set(model.providerID, provider);
+          }
+          await refreshModelLimitsFromApi({
+            config: {
+              providers: async () => ({
+                data: { providers: [...providers.values()] }
+              })
+            }
+          });
+          queriedModels.add(draftModelKey);
+        }
+        const usageDb = db;
+        const limitFor = (providerID, modelID) => {
+          const modelKey = `${providerID}/${modelID}`;
+          const rawLimit = rawLimits.get(modelKey);
+          return rawLimit && !isSaneLimit(rawLimit.context) ? resolveLimit(rawLimit, providerID, modelID) ?? 0 : resolveContextLimit(providerID, modelID, {
+            db: usageDb,
+            sessionID: draft.sessionID
+          });
+        };
+        const reading = resolveUsageReading({
+          rowModel: latest?.data.model,
+          draftModel: { providerID: draft.model.providerID, id: draft.model.id },
+          tokens: latest?.data.tokens,
+          completed: latest?.data.time?.completed ?? (latest?.data.finish ? latest.data.time?.streamed ?? latest.data.time?.created : undefined),
+          finish: latest?.data.finish,
+          error: latest?.data.error,
+          limitFor
+        });
+        if (reading) {
+          persistV2UsageReading({
+            db: usageDb,
+            sessionID: draft.sessionID,
+            draftModel: draft.model,
+            reading,
+            contextUsageMap: usage
+          });
+        }
+      } finally {
+        reader.close();
+      }
+    } catch (error) {
+      reportPreProviderRefusal(draft.sessionID, error);
+      unsafe = true;
+    }
+    return unsafe;
+  };
+  const usageController = new AbortController;
+  const usageDone = (async () => {
+    try {
+      for await (const value of context.event.subscribe({ signal: usageController.signal })) {
+        if (usageController.signal.aborted)
+          break;
+        const event = value;
+        if (!event.data?.sessionID)
+          continue;
+        const sessionID = event.data.sessionID;
+        if (event.type === "session.error" || event.type === "session.execution.failed") {
+          const error = hiddenTerminalError(event);
+          if (error !== undefined)
+            hiddenSessionErrors.set(sessionID, error);
+          continue;
+        }
+        if (event.type === "session.deleted") {
+          deletedSessions.add(sessionID);
+          if (db) {
+            markSessionCleanupPending(db, sessionID);
+            clearSession(db, sessionID);
+          }
+          rawProviders.get(sessionID)?.();
+          rawProviders.delete(sessionID);
+          usage.delete(sessionID);
+          hiddenSessionErrors.delete(sessionID);
+          storageNoticeBySession.delete(sessionID);
+          liveModels.delete(sessionID);
+          variants.delete(sessionID);
+          agents.delete(sessionID);
+          channel1.delete(sessionID);
+          historyRefreshSessions.delete(sessionID);
+          pendingMaterializationSessions.delete(sessionID);
+          lastHeuristicsTurnId.delete(sessionID);
+          restoredRows.forget(sessionID);
+          generateReplay.forget(sessionID);
+          systemPromptRefreshSessions.delete(sessionID);
+          systemPrompt?.clearSession(sessionID);
+          tagger.cleanup(sessionID);
+          continue;
+        }
+        if (event.type !== "session.execution.succeeded")
+          continue;
+        const model = liveModels.get(sessionID);
+        if (model)
+          await recordUsage({
+            sessionID,
+            model: { providerID: model.providerID, id: model.modelID }
+          });
+      }
+    } catch (error) {
+      if (!usageController.signal.aborted)
+        log("[magic-context] v2 usage subscription failed", error);
+    }
+  })();
+  const materialize = (draft) => {
+    db = storage.require();
+    const state = getOrCreateSessionMeta(db, draft.sessionID);
+    return materializeM0({
+      db,
+      sessionId: draft.sessionID,
+      state,
+      projectPath: resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
+      projectDirectory: directory,
+      memoryEnabled: config.memory.enabled && !!resolveProjectIdentityForSession(directory, config.allow_home_project),
+      memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
+      hardSignals: {
+        systemHash: foldDigest(JSON.stringify(draft.system)),
+        toolSetHash: getCurrentToolSetHash(draft.model.providerID, draft.model.id, draft.agent),
+        modelKey: `${draft.model.providerID}/${draft.model.id}`,
+        cacheExpired: false,
+        lastResponseTime: state.lastResponseTime
+      }
+    }).m0Text;
+  };
+  await context.session.hook("compaction", async (draft) => {
+    const hiddenSummary = hiddenChildHook.compactionSummary(draft.sessionID);
+    if (hiddenSummary !== undefined) {
+      draft.result = { summary: hiddenSummary };
+      return;
+    }
+    if (compactionOff)
+      return;
+    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";
+      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}`);
+      draft.result = { summary: fold.submitted };
+    } catch (cause) {
+      await refuseBeforeProvider(context.session, draft.sessionID, "compaction-fold", cause);
+      throw new V2ContextRefusal("Magic Context could not preserve the host checkpoint.", {
+        cause
+      });
+    } finally {
+      reader.close();
+    }
+  });
+  const runManagedContext = async (draft) => {
+    rememberHostMedia(draft.messages);
+    if (hiddenChildHook.apply(draft))
+      return;
+    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");
+        throw new Error("LKG system identity is unavailable or changed");
+      }
+    };
+    const isMagicContextSynthetic = (id) => isAdmittedSynthetic(context, draft.sessionID, id);
+    const newest = draft.messages.at(-1);
+    if (newest && hasStorageNoticeShape(newest) && await isMagicContextSynthetic(newest.id)) {
+      await refuseBeforeProvider(context.session, draft.sessionID, "storage-notice-turn");
+      return;
+    }
+    await dropStorageNotices(draft.messages, isMagicContextSynthetic);
+    liveModels.set(draft.sessionID, {
+      providerID: draft.model.providerID,
+      modelID: draft.model.id
+    });
+    variants.set(draft.sessionID, draft.model.variant);
+    if (!modelLimitCacheWarm())
+      withoutSqliteTransformPass(() => warmModelLimitCacheFromCatalog(context));
+    agents.set(draft.sessionID, draft.agent);
+    applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface);
+    let postFold = false;
+    try {
+      const admissionDb = db ?? storage.current();
+      if (!compactionOff && admissionDb)
+        await withAsyncPrivilegedWriter(admissionDb, () => {
+          return;
+        });
+      if (admissionDb)
+        hideSubagentTools(draft, admissionDb);
+      recordV2ToolDefinitions(draft);
+      if (await recordUsage(draft) && !compactionOff) {
+        const storageReason = storage.current() ? null : storage.reason();
+        if (storageReason) {
+          noticeStorageRefusal(draft.sessionID, storageReason);
+          await refuseBeforeProvider(context.session, draft.sessionID, "storage-unavailable", formatFailClosedBlockingMessage(storageReason));
+          return;
+        }
+        await refuseBeforeProvider(context.session, draft.sessionID, "usage-unavailable");
+        return;
+      }
+      if (!db)
+        return;
+      if (!storageOpenedAtBoot && !storageRecoveryAnnounced) {
+        storageRecoveryAnnounced = true;
+        const recovered = await recoverHiddenWork(db);
+        const message = formatStorageRecoveryNotice(recovered);
+        log(`[magic-context] v2 storage recovered: ${message}`);
+        pushNotification2("toast", { message, variant: "info" }, draft.sessionID);
+        storeStorageNotice(draft.sessionID, message, "recovery");
+      }
+      if (!rustModeModuleClient && !compactionOff)
+        inheritForkState(db, draft.sessionID);
+      try {
+        await rebaseSessionCoordinatesAsync({
+          db,
+          sessionId: draft.sessionID,
+          generation: "v2",
+          readMessages: readAllForConversion,
+          readMessagePages: (sessionID) => readV2RawMessagePagesForConversion(openStoreReader, sessionID)
+        });
+      } catch (error) {
+        sessionLog(draft.sessionID, "store projection rebase failed before system prompt (retrying in transform):", error);
+      }
+      systemPrompt ??= createSystemPromptHashHandler({
+        db,
+        dreamerEnabled: config.dreamer !== undefined && !config.dreamer.disable,
+        memoryEnabled: config.memory.enabled && !!resolveProjectIdentityForSession(directory, config.allow_home_project),
+        language: config.language,
+        promptSurface: config.prompt_surface,
+        promptSurfaceRuntime,
+        systemPromptRefreshSessions,
+        historyRefreshSessions,
+        pendingMaterializationSessions,
+        lastHeuristicsTurnId,
+        injectionEnabled: config.system_prompt_injection.enabled,
+        injectionSkipSignatures: config.system_prompt_injection.skip_signatures
+      });
+      await applyV2SystemPrompt(systemPrompt, draft);
+      await preloadTokenizer();
+      passDuties ??= createChatMessageHook({
+        db,
+        liveModelBySession: liveModels,
+        variantBySession: variants,
+        agentBySession: agents,
+        historyRefreshSessions,
+        pendingMaterializationSessions,
+        lastHeuristicsTurnId,
+        systemPromptRefreshSessions,
+        cacheTtlConfig: config.cache_ttl
+      });
+      await passDuties({
+        sessionID: draft.sessionID,
+        agent: draft.agent,
+        variant: draft.model.variant,
+        model: { providerID: draft.model.providerID, modelID: draft.model.id }
+      });
+      await cacheV2SessionDirectory(context.session, draft.sessionID, sessionDirectories);
+      prepareHistorySession(draft.sessionID);
+      transform ??= createTransform({
+        cacheTtlConfig: config.cache_ttl,
+        cacheTtlConfigured: config.cacheTtlConfigured,
+        sampleCacheTtlConfig: () => liveConfigReader.poll().effective,
+        db,
+        tagger,
+        ...createV2ThresholdDeps(config),
+        contextUsageMap: usage,
+        compactionOff,
+        storeGeneration: "v2",
+        hostCleanupCompactionMarkers: () => ({
+          verified: true,
+          removedLineages: 0,
+          removedRows: 0,
+          retainedLineages: 0
+        }),
+        protectedTokens: config.protected_tokens,
+        protectedTokenTierOverrides: getProtectedTokensTierOverrides(config),
+        liveModelBySession: liveModels,
+        getToolSetHash: (sessionId) => {
+          const model = liveModels.get(sessionId);
+          if (!model)
+            return "";
+          return getCurrentToolSetHash(model.providerID, model.modelID, agents.get(sessionId));
+        },
+        channel1StateBySession: channel1,
+        historyRefreshSessions,
+        pendingMaterializationSessions,
+        lastHeuristicsTurnId,
+        variantBySession: variants,
+        clearReasoningAge: config.clear_reasoning_age,
+        directory,
+        sessionDirectoryBySession: sessionDirectories,
+        projectPath: directory,
+        hiddenCompletionExecutor,
+        historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
+        historianModel: historianModels.primary,
+        fallbackModels: historianModels.fallbacks,
+        resolveHistorianRun: sampleHistorian,
+        historianTimeoutMs: config.historian_timeout_ms,
+        historianMaxOutputTokens: config.historian?.maxTokens,
+        historianTwoPass: config.historian?.two_pass,
+        historianExpandTools: config.historian?.expand_tools,
+        historianRunner: config.historian?.runner,
+        historianHostRunnerEnabled: config.historian?.host_runner?.enabled,
+        compactionMarkerStrategy: rustModeModuleClient ? createV2RustCompactionMarkerStrategy((sessionID, endMessageID) => {
+          const reader = openStoreReader();
+          try {
+            return resolveV2BoundaryUserMessage(reader, sessionID, endMessageID);
+          } finally {
+            reader.close();
+          }
+        }) : v2CompactionMarkerStrategy,
+        transformMode: config.transform_mode,
+        rustModeModuleClient,
+        rustModeProjectRoot: directory,
+        rustMemorySyncRequestedSessions,
+        onRustModeParked: (sessionId, message) => pushNotification2("toast", {
+          message: `Rust Magic Context paused: ${message}`,
+          variant: "warning"
+        }, sessionId),
+        promptSurface: config.prompt_surface,
+        promptSurfaceRuntime,
+        onRustEngineReconnectRefusal: (refusal) => rustRefusalRecovery?.arm(refusal),
+        memoryConfig: {
+          enabled: config.memory.enabled,
+          injectionBudgetTokens: config.memory.injection_budget_tokens,
+          autoPromote: config.memory.auto_promote
+        },
+        ...createHostSeams(context, readAllForConversion, pagedRead, liveModels)
+      });
+      const admitted = new Set;
+      const reader = openStoreReader();
+      let checkpoint;
+      let submitted;
+      try {
+        const candidates = syntheticCandidates(context, draft.sessionID, reader.syntheticMessageIDs(draft.sessionID));
+        for (const message of draft.messages) {
+          if (message.id && candidates.has(message.id) && await isAdmittedSynthetic(context, draft.sessionID, message.id))
+            admitted.add(message.id);
+        }
+        const cut = reader.latestCompaction(draft.sessionID);
+        const boundaryRepair = !rustModeModuleClient && db && !compactionOff ? checkHistoryBoundary(db, reader, draft.sessionID) : undefined;
+        if (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset") {
+          historyRefreshSessions.add(draft.sessionID);
+          pendingMaterializationSessions.add(draft.sessionID);
+        }
+        const incoming = cut && draft.messages.find((message) => message.id === cut.id);
+        postFold = cut !== undefined;
+        if (cut && !incoming)
+          throw new Error("The host checkpoint disappeared from the context draft");
+        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}`);
+              materialize(draft);
+              pendingMaterializationSessions.add(draft.sessionID);
+            }
+          });
+          checkpoint = structuredClone(identity.rendered ?? incoming);
+          submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
+          const moduleBoundaryID = rustModeModuleClient ? getPersistedCompactionMarkerState(db, draft.sessionID)?.boundaryMessageId ?? null : null;
+          const moduleBoundarySeq = moduleBoundaryID ? reader.sequenceForId(draft.sessionID, moduleBoundaryID) : undefined;
+          const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id ?? (boundaryRepair?.kind === "repaired" || boundaryRepair?.kind === "baseline-reset" ? boundaryRepair.anchorEndMessageId : null);
+          const servedBoundary = boundaryID ? servedBoundaryRow(reader, draft.sessionID, boundaryID) : null;
+          const boundary = (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`);
+          const present = new Set(draft.messages.map((message) => message.id));
+          const restored = restoredRows.rows(reader, draft.sessionID, boundary, cut.seq).filter((row) => !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model, hostUsesMediaAssets() ? {
+            asset: hostMediaAsset,
+            unavailable: (detail) => sessionLog(draft.sessionID, `v2 restore: attachment replaced by a note row=${detail.rowID} name=${JSON.stringify(detail.name ?? null)} mediaType=${detail.mediaType} reason=${JSON.stringify(detail.reason)}`)
+          } : undefined));
+          draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
+        }
+      } finally {
+        reader.close();
+      }
+      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`);
+      }
+      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,
+        onLkgReplay: restoreLkgSystem,
+        rustReplayParticipant: () => transform?.getRustReplayParticipant() ?? null
+      })({}, mapped);
+      mapped.commit();
+      if (db) {
+        await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
+      }
+      if (checkpoint && submitted !== undefined) {
+        const head = draft.messages.find((message) => message.id === HEAD_IDS[0]);
+        const baseline = head?.content.find((part) => part.type === "text")?.text;
+        if (typeof baseline === "string") {
+          for (const part of checkpoint.content)
+            if (part.type === "text" && typeof part.text === "string") {
+              part.text = part.text.replace(`<summary>
+${submitted}
+</summary>`, `<summary>
+${baseline}
+</summary>`);
+            }
+          const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
+          if (volatile && head)
+            volatile.content.push(...head.content.filter((part) => part.type !== "text"));
+          draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
+        }
+      }
+      const 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 V2ContextRefusal)
+        throw error;
+      if (!compactionOff && (isTransientSqliteError(error) || error instanceof StorageBusyRefusalError)) {
+        if (isTransientSqliteError(error)) {
+          const mapped = adaptPayload(draft);
+          try {
+            await createMessagesTransformHandler({
+              onLkgReplay: restoreLkgSystem,
+              rustReplayParticipant: () => transform?.getRustReplayParticipant() ?? null,
+              magicContext: {
+                "experimental.chat.messages.transform": async () => {
+                  throw error;
+                }
+              }
+            })({}, mapped);
+            mapped.commit();
+            return;
+          } catch (replayError) {
+            if (!(replayError instanceof StorageBusyRefusalError))
+              throw replayError;
+          }
+        }
+        const refusal = error instanceof StorageBusyRefusalError ? error : new StorageBusyRefusalError(error, "v2-context");
+        pushNotification2("toast", { message: STORAGE_BUSY_MESSAGE, variant: "error" }, draft.sessionID);
+        storeStorageNotice(draft.sessionID, `${STORAGE_NOTICE_PREFIX}${STORAGE_BUSY_MESSAGE}`, "busy");
+        await refuseBeforeProvider(context.session, draft.sessionID, "storage-busy", refusal);
+        throw new V2ContextRefusal(STORAGE_BUSY_MESSAGE, { cause: refusal });
+      }
+      const managedError = !compactionOff && !isBlockingV2TransformError(error) ? new DegradedPassRefusalError("v2-context-failed", { cause: error }) : error;
+      if (isBlockingV2TransformError(managedError)) {
+        if (!compactionOff) {
+          if (managedError instanceof UnresolvedHistoryBoundaryError || managedError instanceof UnmanagedOverWindowError || managedError instanceof DegradedPassRefusalError) {
+            pushNotification2("toast", { message: managedError.message, variant: "error" }, draft.sessionID);
+          }
+          await refuseBeforeProvider(context.session, draft.sessionID, "blocking-transform-error", managedError);
+          throw new V2ContextRefusal("Magic Context refused to send an unsafe prompt.", {
+            cause: managedError
+          });
+        }
+        log("[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);
+      }
+    }
+  };
+  await context.session.hook("context", (draft) => withSqliteTransformPass(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>"))))
+      generateReplay.capture(draft, anchor);
+  }));
+  await context.session.hook("generate", async (draft) => {
+    if (!compactionOff && !deletedSessions.has(draft.sessionID))
+      generateReplay.apply(draft);
+  });
+  withoutSqliteTransformPass(() => warmModelLimitCacheFromCatalog(context));
+  const rpcLiveSessionState = createV2RpcLiveSessionState({
+    liveModelBySession: liveModels,
+    variantBySession: variants,
+    agentBySession: agents,
+    channel1StateBySession: channel1,
+    historyRefreshSessions,
+    pendingMaterializationSessions,
+    systemPromptRefreshSessions,
+    sessionDirectoryBySession: sessionDirectories
+  });
+  const storageDir = getMagicContextStorageDir();
+  const rpcServer = new MagicContextRpcServer(storageDir, directory);
+  let rpcStopped = false;
+  registerRpcHandlers(rpcServer, {
+    directory,
+    config,
+    client: undefined,
+    liveSessionState: rpcLiveSessionState,
+    getDatabase: () => {
+      try {
+        return storage.require();
+      } catch {
+        return null;
+      }
+    },
+    rustModeModuleClient,
+    hiddenCompletionExecutor: storageOpenedAtBoot ? hiddenCompletionExecutor : lateHiddenExecutor,
+    compactionMarkerStrategy: v2CompactionMarkerStrategy,
+    prepareHistorySession,
+    storageDir
+  });
+  const manualDreamer = config.dreamer && config.dreamer.disable !== true ? config.dreamer : undefined;
+  rpcServer.handle("dream", async (params) => {
+    const sessionId = String(params.sessionId ?? "");
+    if (!sessionId)
+      return { ok: false, error: "no session" };
+    if (!manualDreamer || !hiddenCompletionExecutor) {
+      pushNotification2("toast", { message: "Dreaming is not configured for this project.", variant: "warning" }, sessionId);
+      return { ok: false, error: "dreamer unavailable" };
+    }
+    const requested = resolveManualDreamTask(params.task);
+    if (requested.error) {
+      pushNotification2("toast", { message: requested.error, variant: "warning" }, sessionId);
+      return { ok: false, error: requested.error };
+    }
+    try {
+      db = storage.require();
+    } catch {
+      const reason = storage.reason();
+      pushNotification2("toast", {
+        message: `Dreaming is unavailable: ${reason ? formatFailClosedBlockingSummary(reason) : "context storage is not durable."}`,
+        variant: "error"
+      }, sessionId);
+      return { ok: false, error: "storage unavailable" };
+    }
+    const runDb = db;
+    const runExecutor = hiddenCompletionExecutor;
+    runManualDreamNow({
+      db: runDb,
+      dreamer: manualDreamer,
+      projectIdentity: resolveProjectIdentityForSession(directory, config.allow_home_project) ?? "",
+      directory,
+      language: config.language,
+      mural: config.mural,
+      executor: runExecutor,
+      sessionId,
+      ...requested.task !== undefined ? { task: requested.task } : {}
+    }).then(({ summary, unsupportedTasks }) => {
+      const hasSummaryContent = summary.ran.length > 0 || summary.failed.length > 0 || summary.skippedNoWork.length > 0 || (summary.skipped?.length ?? 0) > 0 || summary.deferredBusy.length > 0 || Object.keys(summary.backlogBefore ?? {}).length > 0 || Object.keys(summary.backlogAfter ?? {}).length > 0;
+      const message = [
+        hasSummaryContent || unsupportedTasks.length === 0 ? summarizeManualDream(summary) : undefined,
+        unsupportedTasks.length > 0 ? [
+          renderUserFacingFailure("dream_task_needs_tool_loop", "plain"),
+          formatUnsupportedDreamTasks(unsupportedTasks, userFacingFailureCode("dream_task_needs_tool_loop"))
+        ].join(`
+`) : undefined
+      ].filter((line) => line !== undefined).join(`
+
+`);
+      pushNotification2("action", {
+        action: "show-result-dialog",
+        title: "Magic Context dream run",
+        message
+      }, sessionId);
+    }).catch((error) => {
+      pushNotification2("toast", { message: `Dream run failed: ${getErrorMessage(error)}`, variant: "error" }, sessionId);
+    });
+    return { ok: true };
+  });
+  await registerV2Commands({
+    command: context.command,
+    rpc: rpcServer,
+    directory,
+    compactionEnabled: !compactionOff
+  });
+  setTimeout(() => {
+    if (rpcStopped)
+      return;
+    rpcServer.start().catch((error) => log("[magic-context] v2 RPC server failed to start", error));
+  }, 0);
+  return {
+    async dispose() {
+      rpcStopped = true;
+      rpcServer.stop();
+      transform?.disposeRust();
+      tools?.dispose();
+      usageController.abort();
+      await usageDone;
+      deletedSessions.clear();
+      await dreamTrigger?.dispose();
+      for (const release of rawProviders.values())
+        release();
+      rawProviders.clear();
+      restoredRows.clear();
+      readerPool.close();
+      clearSyntheticCandidates(context);
+    }
+  };
+}
+export {
+  registerContext
+};