@cortexkit/opencode-magic-context 0.49.25 → 0.49.27

package/dist/{index-0s8454t2.js → index-dcqk0y27.js}

@@ -92,12 +92,13 @@ import {
   readRawSessionMessageIdOrdinalsForRange2,
   hasRawSessionMessageById2,
   readRawSessionMessageOrdinalById2,
+  resolveHistorianChunkStart2,
   compareRawSessionMessageOrder2,
   getRawSessionMessageCount2,
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-yrrsp47d.js";
+} from "./index-yzjhx10y.js";
 import {
   getHarness2,
   harnessOwnsOpenCodeStore2
@@ -105,7 +106,8 @@ import {
 import {
   getDataDir,
   ensureCortexKitArtifactGitignore,
-  getProjectMagicContextHistorianDir
+  getProjectMagicContextHistorianDir,
+  getMagicContextStorageDir
 } from "./index-g2q4htwp.js";
 import {
   sanitizeDiagnosticText,
@@ -148,6 +150,14 @@ import {
   MagicContextConfigSchema,
   LIVE_RELOAD_CONFIG_PATHS
 } from "./index-nxrsns5x.js";
+import {
+  tagTombstoneOwnerRange,
+  tagTombstoneOwnerKey,
+  tagRevisionKey,
+  tagIdentityRevisionKey,
+  deleteTagIdentityRevisions,
+  getTableColumnNames
+} from "./index-xrnsygfq.js";
 import {
   providerMass,
   calibrationForModelKey,
@@ -164,11 +174,12 @@ import {
   LATEST_SUPPORTED_VERSION,
   getPersistedSchemaVersion,
   openDatabase
-} from "./index-q7ywt6xt.js";
+} from "./index-4cpc59jv.js";
 import {
   inRootAsyncContext2,
   Database2,
   getSqliteDatabasePath2,
+  prepareCachedStatement2,
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2,
   beginSqliteWriterAsync2
@@ -178,15 +189,20 @@ import {
   resolveProjectIdentity
 } from "./index-kq5w68dp.js";
 import {
-  isPidAlive
+  isPidAlive,
+  readProcessStartTime
 } from "./index-c7phnbvk.js";
 import {
   areRustHistorianSyntheticParts2,
   isStrictGapHealingMessage2,
   noteRawSessionSummaryRowWritten2,
   RawOrdinalsNotReady2,
+  dropRawSessionOrdinalCheckpoints2,
   runSessionWarmupWorker
-} from "./index-7tdtpqrg.js";
+} from "./index-rverk2vz.js";
+import {
+  deleteUnmappedMessageFtsRows2
+} from "./index-v15ne3a3.js";
 import {
   layoutLkgPrefix,
   assembleLkgPrefix,
@@ -197,10 +213,7 @@ import {
   resolveStoredPathWorkspaceIdentity,
   sourceNameForMemory,
   computeWorkspaceEpochFingerprint
-} from "./index-9q1g3c5q.js";
-import {
-  getTableColumnNames
-} from "./index-x9k3mqrf.js";
+} from "./index-7kkphb6c.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY,
@@ -215,7 +228,7 @@ import {
 import {
   BoundedSessionMap,
   getMeasuredToolDefinitionTokens
-} from "./index-cfaet9cg.js";
+} from "./index-s1n8dd2n.js";
 import {
   invalidateAutoEmbedSession,
   drainBackgroundBatches,
@@ -224,7 +237,7 @@ import {
   getProjectChunkEmbeddingModelId2,
   getProjectEmbeddingMaxInputTokens2,
   embedItemsForProject2
-} from "./index-z05n7702.js";
+} from "./index-a2fz9hpa.js";
 import {
   buildCanonicalChunkTextFromFts2,
   buildCompartmentSummaryFallbackText2,
@@ -234,23 +247,14 @@ import {
   replaceCompartmentChunkEmbeddings2,
   deleteChunkEmbedBackoffForSession2,
   chunkWindowSourceKey2
-} from "./index-3d5wnkq7.js";
+} from "./index-mm93m7y6.js";
 import {
   clearCompressionDepth,
   clearCompressionDepthRange,
-  clearLkgFenceProcessState,
-  lkgFenceRequiresRebuild,
-  lkgRecoveryFenceUnclean,
-  ownsLkgDirtyFence,
-  commitLkgWithRecoveryFence,
-  clearLkgRecoveryFence,
-  gaDatabasePath,
-  V2StoreReader,
-  deleteSessionScopedRows,
-  toMessageIndexSource2,
-  clearIndexedMessagesInTransaction2,
-  indexSourcesAfterOrdinal2
-} from "./index-awcftgmx.js";
+  toMessageIndexSource,
+  clearIndexedMessagesInTransaction,
+  indexSourcesAfterOrdinal
+} from "./index-7gbcg8xv.js";
 import {
   stripWellFormedLeadingTagPrefix,
   stripTagPrefix,
@@ -263,12 +267,12 @@ import {
   foldShrunkPartTags2,
   getTagNumberByMessageId2,
   getActiveTagsBySession2
-} from "./index-whcgcfrv.js";
+} from "./index-np3rgfw4.js";
 import {
   openCodeDbExists,
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-c9zrgcnt.js";
+} from "./index-v0dhhxsq.js";
 import {
   renderUserFacingFailure,
   userFacingFailureCode,
@@ -277,7 +281,7 @@ import {
   insertPrimerCandidates,
   promoteSessionFactsDurable,
   embedPromotedFacts
-} from "./index-z928hmnp.js";
+} from "./index-t3rbb8wr.js";
 import {
   pushNotification2
 } from "./index-x8a7jmkh.js";
@@ -297,7 +301,7 @@ import {
 } from "./index-qgh1qwjj.js";
 import {
   sendStatusNotification2
-} from "./index-jcr6pe7z.js";
+} from "./index-077ht5cq.js";
 import {
   isCompactionEnabled,
   migrateLegacyAgentEnabledInMemory
@@ -305,6 +309,9 @@ import {
 import {
   piModelRefToCanonical
 } from "./index-avwt563y.js";
+import {
+  sameProjectDirectory
+} from "./index-knvkbfvh.js";
 import {
   getErrorMessage,
   describeError
@@ -318,7 +325,11 @@ import {
 } from "./index-t5pck3ss.js";
 import {
   ensureStorageDirectorySync,
-  writeStorageFileAtomicSync
+  ensurePrivateStorageDirectorySync,
+  writeStorageFileSync,
+  writeStorageFileAtomicSync,
+  syncStorageDirectorySync,
+  writeStorageFileDurableAtomicSync
 } from "./index-fvnzcnww.js";
 
 // src/agents/permissions.ts
@@ -3373,6 +3384,84 @@ function createDreamerOutputCapSampler(boot, fresh) {
   };
 }
 
+// src/features/magic-context/session-activity.ts
+var PREFIX = "retrospective_activity:";
+var INTERVAL_MS = 15000;
+var pending = new WeakMap;
+function sessionActivityKey(sessionId) {
+  return `${PREFIX}${sessionId}`;
+}
+function deleteSessionActivity(db, sessionIds) {
+  if (sessionIds.length === 0)
+    return;
+  const sessions = pending.get(db);
+  for (const sessionId of sessionIds) {
+    const state = sessions?.get(sessionId);
+    if (state?.timer)
+      clearTimeout(state.timer);
+    sessions?.delete(sessionId);
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  db.prepare(`DELETE FROM schema_migrations_meta WHERE key IN (${placeholders})`).run(...sessionIds.map(sessionActivityKey));
+  deleteTagIdentityRevisions(db, sessionIds);
+}
+function advanceSessionActivity(db, sessionId, time) {
+  if (!sessionId || !Number.isFinite(time) || time <= 0)
+    return;
+  db.prepare(`INSERT INTO schema_migrations_meta (key, value) VALUES (?, ?)
+        ON CONFLICT(key) DO UPDATE SET value = CAST(MAX(CAST(value AS INTEGER), CAST(excluded.value AS INTEGER)) AS TEXT)`).run(sessionActivityKey(sessionId), String(Math.floor(time)));
+}
+function observeSessionActivity(db, sessionId, time = Date.now()) {
+  if (!sessionId || !Number.isFinite(time) || time <= 0)
+    return;
+  let sessions = pending.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    pending.set(db, sessions);
+  }
+  const current = sessions.get(sessionId);
+  if (!current || time - current.lastWrite >= INTERVAL_MS) {
+    if (current?.timer)
+      clearTimeout(current.timer);
+    advanceSessionActivity(db, sessionId, Math.max(time, current?.latest ?? 0));
+    sessions.set(sessionId, { lastWrite: time, latest: time });
+    return;
+  }
+  current.latest = Math.max(current.latest, time);
+  if (!current.timer) {
+    current.timer = setTimeout(() => {
+      current.timer = undefined;
+      try {
+        advanceSessionActivity(db, sessionId, current.latest);
+        current.lastWrite = Date.now();
+      } catch {
+        sessions.delete(sessionId);
+      }
+    }, Math.max(1, INTERVAL_MS - (time - current.lastWrite)));
+    current.timer.unref?.();
+  }
+}
+async function backfillSessionActivity(db, harness, latestTime) {
+  const completedKey = `retrospective_activity_backfill:${harness}:v1`;
+  if (db.prepare("SELECT 1 FROM schema_migrations_meta WHERE key = ?").get(completedKey))
+    return;
+  let cursor = "";
+  while (true) {
+    const rows = db.prepare(`SELECT session_id FROM session_projects
+            WHERE harness = ? AND session_id > ? ORDER BY session_id LIMIT 100`).all(harness, cursor);
+    if (rows.length === 0)
+      break;
+    for (const row of rows) {
+      const time = await latestTime(row.session_id);
+      if (time !== undefined)
+        advanceSessionActivity(db, row.session_id, time);
+    }
+    cursor = rows[rows.length - 1].session_id;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  db.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, 'completed')").run(completedKey);
+}
+
 // src/features/magic-context/memory-enabled.ts
 function isProjectMemoryEnabled(enabled) {
   return enabled !== false;
@@ -4929,10 +5018,10 @@ function readProjectDocsCanonical(projectDirectory) {
   return { renderedBlock, canonicalHash };
 }
 // src/hooks/magic-context/lkg-slot.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 
 // src/hooks/magic-context/lkg-measured-request.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // src/shared/provider-response-completion.ts
 function providerResponseFailed(input) {
@@ -4949,8 +5038,432 @@ function isSuccessfulProviderCompletion(input) {
 // src/features/magic-context/storage-meta-session.ts
 import { Buffer as Buffer2 } from "node:buffer";
 
+// src/hooks/magic-context/lkg-recovery-fence.ts
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
+import { lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync7, rmdirSync, rmSync as rmSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname4, join as join4 } from "node:path";
+
+// src/shared/storage-file-mutex.ts
+import { execFileSync } from "node:child_process";
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import { readdirSync, readFileSync as readFileSync6, rmSync as rmSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var ticketChecksum = (name, ticket) => createHash3("sha256").update(JSON.stringify([name, ticket.choosing, ticket.number, ticket.birth])).digest("hex");
+function processBirth(pid) {
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync6(`/proc/${pid}/stat`, "utf8");
+      const ticks = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/)[19];
+      if (!ticks || !/^\d+$/.test(ticks))
+        return null;
+      return `${readFileSync6("/proc/sys/kernel/random/boot_id", "utf8").trim()}:${ticks}`;
+    } catch {
+      return null;
+    }
+  }
+  if (process.platform === "darwin") {
+    try {
+      return execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+        encoding: "utf8",
+        timeout: 1000,
+        windowsHide: true,
+        env: { ...process.env, TZ: "UTC", LC_ALL: "C" },
+        stdio: ["ignore", "pipe", "pipe"]
+      }).trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  const start = readProcessStartTime(pid);
+  return start === null ? null : String(start);
+}
+var pause = new Int32Array(new SharedArrayBuffer(4));
+function withStorageFileMutex(directory, work, timeoutMs = 1000) {
+  ensurePrivateStorageDirectorySync(directory);
+  const name = `${process.pid}-${randomUUID()}.lock`;
+  const ownPath = join3(directory, name);
+  const birth = processBirth(process.pid);
+  const ticket = { choosing: true, number: 0, birth, checksum: "" };
+  const encodedTicket = () => JSON.stringify({ ...ticket, checksum: ticketChecksum(name, ticket) });
+  for (let attempt = 0;; attempt++) {
+    try {
+      writeStorageFileSync(ownPath, encodedTicket(), { flag: "wx", forcePrivate: true });
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT" || attempt >= 2)
+        throw error;
+      ensurePrivateStorageDirectorySync(directory);
+    }
+  }
+  const deadline = performance.now() + timeoutMs;
+  const peers = () => {
+    const found = [];
+    for (const other of readdirSync(directory)) {
+      if (other === name || !/^\d+-[\da-f-]+\.lock$/.test(other))
+        continue;
+      const pid = Number(other.split("-")[0]);
+      const otherPath = join3(directory, other);
+      let value = null;
+      try {
+        const parsed = JSON.parse(readFileSync6(otherPath, "utf8"));
+        if (typeof parsed.choosing === "boolean" && Number.isSafeInteger(parsed.number) && parsed.number >= 0 && (parsed.birth === null || typeof parsed.birth === "string") && parsed.checksum === ticketChecksum(other, parsed))
+          value = parsed;
+      } catch (error) {
+        if (error.code === "ENOENT")
+          continue;
+      }
+      const alive = isPidAlive(pid);
+      const actualBirth = alive === "alive" && value?.birth ? processBirth(pid) : null;
+      if (alive === "dead" || actualBirth !== null && value?.birth && actualBirth !== value.birth) {
+        rmSync2(otherPath, { force: true });
+        continue;
+      }
+      found.push([other, value]);
+    }
+    return found;
+  };
+  try {
+    ticket.number = 1 + Math.max(0, ...peers().map(([, value]) => value?.number ?? 0));
+    ticket.choosing = false;
+    writeStorageFileAtomicSync(ownPath, encodedTicket(), true);
+    while (peers().some(([other, value]) => !value || value.choosing || value.number < ticket.number || value.number === ticket.number && other < name)) {
+      if (performance.now() >= deadline)
+        throw new Error("Storage safety publication lock is unavailable");
+      Atomics.wait(pause, 0, 0, 10);
+    }
+    const result = work();
+    if (result && typeof result.then === "function")
+      throw new TypeError("Storage publication mutex requires synchronous work");
+    return result;
+  } finally {
+    rmSync2(ownPath, { force: true });
+  }
+}
+
+// src/hooks/magic-context/lkg-recovery-fence.ts
+class LkgRecoveryFenceError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LkgRecoveryFenceError";
+  }
+}
+var platform = process.platform;
+var observer;
+var knownFences = new BoundedSessionMap(1000);
+var ioObserver;
+var cacheKey = (sessionId) => `${getMagicContextStorageDir()}\x00${getHarness2()}\x00${sessionId}`;
+function remember(sessionId, value) {
+  knownFences.set(cacheKey(sessionId), value);
+  return value;
+}
+function known(sessionId) {
+  const prior = knownFences.get(cacheKey(sessionId));
+  if (prior)
+    return prior;
+  const record = read(sessionId);
+  if (record)
+    return remember(sessionId, { state: record.state, record });
+  try {
+    lstatSync2(lkgRecoveryFencePath(sessionId));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return remember(sessionId, { state: "clean", record: null });
+  }
+  return remember(sessionId, { state: "invalid", record: null });
+}
+function clearLkgFenceProcessState(sessionId) {
+  if (sessionId)
+    knownFences.delete(cacheKey(sessionId));
+  else
+    knownFences.clear();
+}
+var durableFencesSupported = () => platform !== "win32";
+var hash = (value) => createHash4("sha256").update(value).digest("hex");
+var lkgServedArrayDigest = hash;
+function lkgRecoveryFencePath(sessionId) {
+  return join4(getMagicContextStorageDir(), "lkg-recovery-fences", `${hash(sessionId)}.json`);
+}
+function metadata(slot) {
+  return [
+    slot.inputIdSeq,
+    slot.inputContentDigests,
+    slot.inputContentSignatures ?? null,
+    slot.piOutputEntryIds ?? null,
+    slot.lastInputMessageId,
+    slot.modelKey,
+    slot.providerKey
+  ];
+}
+function representationKey(slot) {
+  return createHash4("sha256").update(slot.jsonPrefix).update(JSON.stringify(metadata(slot))).digest("hex");
+}
+function lkgRecoverySlotKey(slot) {
+  return hash(JSON.stringify([
+    representationKey(slot),
+    slot.capturedAt,
+    slot.rowVersion ?? null,
+    slot.captureSequence ?? null
+  ]));
+}
+function payload(record) {
+  return [
+    record.version,
+    record.sessionId,
+    record.host,
+    record.modelKey,
+    record.providerKey,
+    record.slotKey,
+    record.servedDigest,
+    record.revision,
+    record.state
+  ];
+}
+function publishRecord(record) {
+  ioObserver?.("write");
+  try {
+    if (record.state === "clean")
+      observer?.("clean");
+    writeStorageFileDurableAtomicSync(lkgRecoveryFencePath(record.sessionId), JSON.stringify({ ...record, checksum: hash(JSON.stringify(payload(record))) }), () => observer?.("temp-synced"));
+    if (record.state === "dirty")
+      observer?.("dirty");
+    remember(record.sessionId, {
+      state: record.state,
+      record: { ...record, checksum: hash(JSON.stringify(payload(record))) }
+    });
+  } catch (error) {
+    const visible = read(record.sessionId);
+    if (record.state === "clean" && visible?.state === "clean" && visible.revision === record.revision && visible.slotKey === record.slotKey) {
+      const dirty = { ...record, state: "dirty" };
+      writeStorageFileDurableAtomicSync(lkgRecoveryFencePath(record.sessionId), JSON.stringify({ ...dirty, checksum: hash(JSON.stringify(payload(dirty))) }));
+    }
+    remember(record.sessionId, { state: "invalid", record: null });
+    throw error;
+  }
+}
+function read(sessionId) {
+  ioObserver?.("read");
+  try {
+    const path = lkgRecoveryFencePath(sessionId);
+    const stat = lstatSync2(path);
+    const directory = lstatSync2(dirname4(path));
+    if (!stat.isFile() || stat.size > 4096 || !directory.isDirectory() || directory.isSymbolicLink() || process.platform !== "win32" && ((stat.mode & 63) !== 0 || (directory.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid()))
+      return null;
+    const value = JSON.parse(readFileSync7(path, "utf8"));
+    if (value.version !== 1 || value.sessionId !== sessionId || value.host !== getHarness2() || value.modelKey !== null && typeof value.modelKey !== "string" || value.providerKey !== null && typeof value.providerKey !== "string" || !/^[a-f0-9]{64}$/.test(value.slotKey) || !/^[a-f0-9]{64}$/.test(value.servedDigest) || typeof value.revision !== "string" || !["clean", "dirty"].includes(value.state) || value.checksum !== hash(JSON.stringify(payload(value))))
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function publish(sessionId, slot, state, revision) {
+  const record = {
+    version: 1,
+    sessionId,
+    host: getHarness2(),
+    modelKey: slot.modelKey,
+    providerKey: slot.providerKey,
+    slotKey: lkgRecoverySlotKey(slot),
+    servedDigest: hash(slot.jsonPrefix),
+    revision,
+    state
+  };
+  publishRecord(record);
+}
+function locked(sessionId, work) {
+  ioObserver?.("mutex");
+  return withStorageFileMutex(`${lkgRecoveryFencePath(sessionId)}.locks`, () => {
+    const path = lkgRecoveryFencePath(sessionId);
+    for (const name of readdirSync2(dirname4(path))) {
+      if (name.startsWith(`${basename3(path)}.`) && name.endsWith(".tmp"))
+        rmSync3(join4(dirname4(path), name), { force: true });
+    }
+    return work();
+  });
+}
+function hasCleanLkgRecoveryFence(sessionId, _slot) {
+  if (!durableFencesSupported())
+    return false;
+  const state = known(sessionId);
+  return state.state === "clean";
+}
+function lkgFenceRequiresRebuild(sessionId, slot, processLocalProof) {
+  return !processLocalProof && (durableFencesSupported() ? !hasCleanLkgRecoveryFence(sessionId, slot) : true);
+}
+function lkgRecoveryFenceUnclean(sessionId) {
+  return durableFencesSupported() && known(sessionId).state !== "clean";
+}
+function dirtyLkgRecoveryRevision(sessionId, _slot) {
+  if (!durableFencesSupported())
+    return;
+  const record = known(sessionId).record;
+  return record?.state === "dirty" ? record.revision : undefined;
+}
+function ownsLkgDirtyFence(sessionId, revision) {
+  if (!durableFencesSupported())
+    return revision === "process-local";
+  const record = known(sessionId).record;
+  return revision !== undefined && record?.state === "dirty" && record.revision === revision;
+}
+function invalidateCleanLkgRecoveryFence(sessionId, load, ownRevision) {
+  if (!durableFencesSupported())
+    return "process-local";
+  const prior = known(sessionId);
+  if (prior.state === "dirty")
+    return prior.record?.revision === ownRevision ? ownRevision : undefined;
+  return locked(sessionId, () => {
+    const slot = load() ?? {
+      jsonPrefix: "",
+      inputIdSeq: [],
+      inputContentDigests: [],
+      lastInputMessageId: "",
+      modelKey: null,
+      providerKey: null,
+      capturedAt: 0
+    };
+    const record = read(sessionId);
+    if (record?.state !== "dirty") {
+      const revision = randomUUID2();
+      publish(sessionId, slot, "dirty", revision);
+      return revision;
+    }
+    return record?.state === "dirty" && record.revision === ownRevision ? ownRevision : undefined;
+  });
+}
+function prepareLkgCaptureFence(args) {
+  if (!durableFencesSupported())
+    return "process-local";
+  return locked(args.sessionId, () => {
+    const before = read(args.sessionId);
+    const owns = before?.state === "dirty" && before.revision === args.ownDirtyRevision;
+    const unchangedBytes = before?.state === "clean" && before.servedDigest === hash(args.slot.jsonPrefix);
+    if (!args.rebuild && before && !owns && !unchangedBytes && before.state !== "clean")
+      throw new LkgRecoveryFenceError(`A concurrent recovery requires a declared prefix rebuild (state=${before?.state}, owned=${owns}, previous=${!!args.previousSlot}, bytes=${unchangedBytes})`);
+    const revision = randomUUID2();
+    if (before)
+      publishRecord({ ...before, state: "dirty", revision });
+    else
+      publish(args.sessionId, args.previousSlot ?? args.slot, "dirty", revision);
+    return revision;
+  });
+}
+function certifyCommittedLkgCapture(args) {
+  if (!durableFencesSupported())
+    return false;
+  const state = known(args.sessionId);
+  if (state.state !== "dirty" || state.record?.revision !== args.revision)
+    return false;
+  return locked(args.sessionId, () => {
+    const before = read(args.sessionId);
+    if (before?.state !== "dirty" || before.revision !== args.revision)
+      return false;
+    const saved = args.load();
+    if (!saved || representationKey(saved) !== representationKey(args.slot) || hash(saved.jsonPrefix) !== args.latestServedDigest)
+      return false;
+    publish(args.sessionId, saved, "clean", args.revision);
+    return true;
+  });
+}
+function markLkgRecoveryDirty(args) {
+  if (!durableFencesSupported()) {
+    if (!args.processLocalProof)
+      throw new LkgRecoveryFenceError("Restart replay requires a healthy rebuild on Windows");
+    return "process-local";
+  }
+  const state = known(args.sessionId);
+  if (state.state === "dirty" && args.processLocalProof && state.record && state.record.revision === args.ownDirtyRevision)
+    return state.record.revision;
+  if (state.state === "invalid")
+    throw new LkgRecoveryFenceError("No clean durable recovery certificate");
+  return locked(args.sessionId, () => {
+    const slot = args.slot;
+    const before = read(args.sessionId);
+    if (before?.state === "dirty") {
+      if (!args.processLocalProof || before.revision !== args.ownDirtyRevision)
+        throw new LkgRecoveryFenceError(`Recovery superseded this process's last-good request (local=${args.processLocalProof}, owned=${before.revision === args.ownDirtyRevision})`);
+      return before.revision;
+    }
+    if (before && before.state !== "clean")
+      throw new LkgRecoveryFenceError("No clean durable recovery certificate");
+    const revision = randomUUID2();
+    publish(args.sessionId, slot, "dirty", revision);
+    return revision;
+  });
+}
+function commitLkgWithRecoveryFence(args) {
+  if (!durableFencesSupported())
+    return args.commit();
+  const state = known(args.sessionId);
+  if (state.state === "clean" && !args.requiredRevision && !args.retainDirtyRevision) {
+    const committed = args.commit();
+    if (committed) {
+      observer?.("committed");
+      remember(args.sessionId, { state: "clean", record: null });
+    }
+    return committed;
+  }
+  if (state.state === "invalid" && !args.rebuild)
+    throw new LkgRecoveryFenceError("Unproven prior request requires a prefix rebuild");
+  return locked(args.sessionId, () => {
+    const before = read(args.sessionId);
+    if (args.requiredRevision && before?.revision !== args.requiredRevision)
+      throw new LkgRecoveryFenceError("A later publisher superseded the rollback snapshot");
+    const ownsDirty = before?.state === "dirty" && (before.revision === args.retainDirtyRevision || before.revision === args.ownDirtyRevision);
+    if (before?.state === "dirty" && !ownsDirty && !args.rebuild)
+      throw new LkgRecoveryFenceError("A concurrent recovery requires a declared prefix rebuild");
+    if (before?.state !== "dirty" && state.state === "invalid")
+      publish(args.sessionId, args.load() ?? args.slot, "dirty", randomUUID2());
+    if (!args.commit())
+      return false;
+    observer?.("committed");
+    const saved = args.load();
+    if (!saved || representationKey(saved) !== representationKey(args.slot))
+      throw new LkgRecoveryFenceError("Last-good commit did not match its certificate");
+    if (args.retainDirtyRevision || args.cleanDigest !== undefined && hash(saved.jsonPrefix) !== args.cleanDigest)
+      return true;
+    const dirty = read(args.sessionId);
+    if (dirty?.state === "dirty")
+      publish(args.sessionId, saved, "clean", dirty.revision);
+    else
+      remember(args.sessionId, { state: "clean", record: null });
+    return true;
+  });
+}
+function clearLkgRecoveryFence(sessionId, remove, shouldClear) {
+  if (!durableFencesSupported())
+    return remove?.();
+  const path = lkgRecoveryFencePath(sessionId);
+  const missing = (file) => {
+    try {
+      lstatSync2(file);
+      return false;
+    } catch (error) {
+      return error.code === "ENOENT";
+    }
+  };
+  if (!remove && !shouldClear && missing(path) && missing(`${path}.locks`)) {
+    clearLkgFenceProcessState(sessionId);
+    return;
+  }
+  try {
+    return locked(sessionId, () => {
+      const result = remove?.();
+      if (shouldClear && !shouldClear(result))
+        return result;
+      rmSync3(lkgRecoveryFencePath(sessionId), { force: true });
+      syncStorageDirectorySync(dirname4(lkgRecoveryFencePath(sessionId)));
+      clearLkgFenceProcessState(sessionId);
+      return result;
+    });
+  } finally {
+    try {
+      rmdirSync(`${path}.locks`);
+    } catch {}
+  }
+}
+
 // src/shared/auto-search-lifecycle.ts
-var pending = new Map;
+var pending2 = new Map;
 var unpublishedNoHints = new Map;
 function rememberUnpublishedAutoSearchNoHint(sessionId, messageId, reason) {
   let messages = unpublishedNoHints.get(sessionId);
@@ -4978,28 +5491,731 @@ function clearUnpublishedAutoSearchNoHints(sessionId) {
 }
 function registerAutoSearchWork(sessionId) {
   const controller = new AbortController;
-  const work = pending.get(sessionId) ?? new Set;
-  pending.set(sessionId, work);
+  const work = pending2.get(sessionId) ?? new Set;
+  pending2.set(sessionId, work);
   work.add(controller);
   return {
     signal: controller.signal,
     done: () => {
       work.delete(controller);
-      if (pending.get(sessionId) === work && work.size === 0)
-        pending.delete(sessionId);
+      if (pending2.get(sessionId) === work && work.size === 0)
+        pending2.delete(sessionId);
     }
   };
 }
 function cancelAutoSearchWork(sessionId) {
-  for (const [id, work] of pending) {
+  for (const [id, work] of pending2) {
     if (sessionId !== undefined && id !== sessionId)
       continue;
-    pending.delete(id);
+    pending2.delete(id);
     for (const controller of work)
       controller.abort();
   }
 }
 
+// src/v2/store-reader.ts
+import { createHash as createHash5 } from "node:crypto";
+import { statSync as statSync5 } from "node:fs";
+import { hostname } from "node:os";
+import { resolve as resolve2 } from "node:path";
+function gaDatabasePath(dataHome, channel = "latest", env = process.env) {
+  return resolveOpenCodeDbPath("v2", { dataHome, channel, env }).path;
+}
+var RAW_MESSAGE_TYPES = [
+  "user",
+  "synthetic",
+  "assistant",
+  "skill",
+  "shell",
+  "system"
+];
+var RAW_MESSAGE_TYPE_PARAMETERS = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+var V2_MESSAGE_PAGE_SQL = `WITH bounds AS (
+    SELECT
+        CASE WHEN ? = 0 THEN -1 ELSE COALESCE((
+            SELECT seq FROM session_message
+            WHERE session_id = ? AND type IN (${RAW_MESSAGE_TYPE_PARAMETERS})
+            ORDER BY seq ASC LIMIT 1 OFFSET ?
+        ), (SELECT MAX(seq) FROM session_message WHERE session_id = ?), -1) END AS after_seq,
+        COALESCE((
+            SELECT seq FROM session_message
+            WHERE session_id = ? AND type IN (${RAW_MESSAGE_TYPE_PARAMETERS})
+            ORDER BY seq ASC LIMIT 1 OFFSET ?
+        ), ?) AS watermark_seq
+)
+SELECT id, session_id, type, seq, time_created, data FROM session_message, bounds
+WHERE session_id = ?
+  AND type IN (${RAW_MESSAGE_TYPE_PARAMETERS})
+  AND seq > bounds.after_seq
+  AND seq <= bounds.watermark_seq
+ORDER BY seq ASC LIMIT ?`;
+var V2_STORE_READER_DEBUG_COUNTER_KEY = "magic-context.v2.store-reader-debug";
+var debugSymbol = Symbol.for(V2_STORE_READER_DEBUG_COUNTER_KEY);
+var debugGlobal = globalThis;
+var QUERY_STATEMENTS = {
+  messagePage: V2_MESSAGE_PAGE_SQL,
+  messageCount: "SELECT COUNT(*) AS count FROM session_message WHERE session_id = ? AND type IN (?)",
+  storedMessageCount: "SELECT COUNT(*) AS count FROM session_message WHERE session_id = ?",
+  messageById: "SELECT id, session_id, type, seq, time_created, data FROM session_message WHERE session_id = ? AND id = ? AND type IN (?) LIMIT 1",
+  messageExistsById: "SELECT 1 FROM session_message WHERE id = ? AND session_id = ? AND type IN (?) LIMIT 1",
+  messageOrdinalById: `WITH target AS (
+    SELECT seq FROM session_message WHERE session_id = ? AND id = ? AND type IN (?) LIMIT 1
+)
+SELECT (SELECT COUNT(*) FROM session_message WHERE session_id = ? AND type IN (?) AND seq <= target.seq) AS ordinal FROM target`,
+  messageIdOrdinals: "SELECT id FROM session_message WHERE session_id = ? AND type IN (?) ORDER BY seq ASC LIMIT ? OFFSET ?",
+  messageOrdinalPage: "SELECT id, type, seq, json_valid(data) AS valid FROM session_message WHERE session_id = ? AND seq > ? ORDER BY seq ASC, id ASC LIMIT ?",
+  rawRowsThrough: "SELECT id, session_id, type, seq, time_created, data FROM session_message WHERE session_id = ? AND type IN (?) AND seq <= ? ORDER BY seq DESC LIMIT ?"
+};
+function debugCounters() {
+  const counters = debugGlobal[debugSymbol] ??= {
+    decodedRows: 0,
+    operations: {},
+    openReaders: 0,
+    maxOpenReaders: 0,
+    readersOpened: 0,
+    readersClosed: 0
+  };
+  counters.openReaders ??= 0;
+  counters.maxOpenReaders ??= 0;
+  counters.readersOpened ??= 0;
+  counters.readersClosed ??= 0;
+  return counters;
+}
+function returnedRowCount(value) {
+  if (Array.isArray(value))
+    return value.length;
+  if (value === null || value === undefined || value === false)
+    return 0;
+  return 1;
+}
+function trackDecodeOperation(name, operation) {
+  const counters = debugCounters();
+  const before = counters.decodedRows;
+  const started = performance.now();
+  let value;
+  try {
+    value = operation();
+    return value;
+  } finally {
+    const decodedRows = counters.decodedRows - before;
+    const current = counters.operations[name] ?? {
+      calls: 0,
+      decodedRows: 0,
+      maxDecodedRows: 0
+    };
+    current.calls += 1;
+    current.decodedRows += decodedRows;
+    current.maxDecodedRows = Math.max(current.maxDecodedRows, decodedRows);
+    counters.operations[name] = current;
+    const statement = QUERY_STATEMENTS[name];
+    if (counters.captureQueries && statement) {
+      (counters.queries ??= []).push({
+        operation: name,
+        statement,
+        rows: returnedRowCount(value),
+        elapsedMs: performance.now() - started
+      });
+    }
+  }
+}
+function decode(row) {
+  debugCounters().decodedRows += 1;
+  const data = JSON.parse(row.data);
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error(`Invalid session_message data at seq ${row.seq}`);
+  }
+  if (row.type === "idle" && !["succeeded", "failed", "interrupted"].includes(String(data.outcome))) {
+    throw new Error(`Invalid idle outcome at seq ${row.seq}`);
+  }
+  return { ...row, data };
+}
+function connect(path, identity = "") {
+  const stat = statSync5(path);
+  const acquiredIdentity = identity || `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+  const db = new Database2(path, { readonly: true, fileMustExist: true });
+  try {
+    assertOpenCodeStoreGeneration(db, "v2", path);
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+  const counters = debugCounters();
+  counters.openReaders += 1;
+  counters.readersOpened += 1;
+  counters.maxOpenReaders = Math.max(counters.maxOpenReaders, counters.openReaders);
+  return { db, statements: new Map, identity: acquiredIdentity, leases: 0, retired: false };
+}
+function closeConnection(connection) {
+  connection.statements.clear();
+  try {
+    connection.db.close();
+  } finally {
+    const counters = debugCounters();
+    counters.openReaders = Math.max(0, counters.openReaders - 1);
+    counters.readersClosed += 1;
+  }
+}
+
+class V2StoreReaderPool {
+  capacity;
+  connections = new Map;
+  closed = false;
+  closing = false;
+  holds = 0;
+  idleWaiters = new Set;
+  constructor(capacity = 4) {
+    this.capacity = capacity;
+    if (!Number.isSafeInteger(capacity) || capacity < 1)
+      throw new Error("Invalid reader capacity");
+  }
+  open(path) {
+    return new V2StoreReader(path, this);
+  }
+  acquire(path) {
+    if (this.closed)
+      throw new Error("Store reader pool is closed");
+    const key = resolve2(path);
+    const stat = statSync5(key);
+    const identity = `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+    let connection = this.connections.get(key);
+    if (connection && connection.identity !== identity) {
+      this.connections.delete(key);
+      this.retire(connection);
+      connection = undefined;
+    }
+    if (!connection)
+      connection = connect(key, identity);
+    connection.leases++;
+    this.connections.delete(key);
+    this.connections.set(key, connection);
+    while (this.connections.size > this.capacity) {
+      const oldest = this.connections.entries().next().value;
+      if (!oldest)
+        break;
+      this.connections.delete(oldest[0]);
+      this.retire(oldest[1]);
+    }
+    return connection;
+  }
+  release(connection) {
+    connection.leases--;
+    if (connection.retired && connection.leases === 0)
+      closeConnection(connection);
+  }
+  retire(connection) {
+    connection.retired = true;
+    if (connection.leases === 0)
+      closeConnection(connection);
+  }
+  hold() {
+    if (this.closed || this.closing)
+      throw new Error("Store reader pool is closed");
+    this.holds++;
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      this.holds--;
+      if (this.holds === 0 && this.closing)
+        this.finishClose();
+    };
+  }
+  isClosed() {
+    return this.closed;
+  }
+  holdCount() {
+    return this.holds;
+  }
+  close() {
+    if (this.closed || this.closing)
+      return;
+    this.closing = true;
+    if (this.holds === 0)
+      this.finishClose();
+  }
+  async closeWhenIdle(timeoutMs) {
+    this.close();
+    if (this.closed)
+      return true;
+    let timer;
+    let waiter;
+    try {
+      await new Promise((resolve) => {
+        waiter = resolve;
+        this.idleWaiters.add(resolve);
+        timer = setTimeout(resolve, Math.max(0, timeoutMs));
+      });
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      if (waiter)
+        this.idleWaiters.delete(waiter);
+    }
+    return this.closed;
+  }
+  finishClose() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    for (const connection of this.connections.values())
+      this.retire(connection);
+    this.connections.clear();
+    for (const resolve of this.idleWaiters)
+      resolve();
+    this.idleWaiters.clear();
+  }
+}
+function messageTimesQuery(count) {
+  return `SELECT id, COALESCE(time_created, json_extract(data, '$.time.created')) AS created,
+                   json_extract(data, '$.time.completed') AS completed
+            FROM session_message WHERE +session_id = ? AND id IN (${Array.from({ length: count }, () => "?").join(",")})`;
+}
+
+class V2StoreReader {
+  path;
+  pool;
+  db;
+  connection;
+  closed = false;
+  constructor(path, pool) {
+    this.path = path;
+    this.pool = pool;
+    this.connection = pool ? pool.acquire(path) : connect(path);
+    this.db = this.connection.db;
+  }
+  hostIdentity() {
+    return createHash5("sha256").update(JSON.stringify([hostname(), resolve2(this.path), this.connection.identity])).digest("hex");
+  }
+  prepare(sql) {
+    if (this.closed)
+      throw new Error("Store reader is closed");
+    const statements = this.connection.statements;
+    let statement = statements.get(sql);
+    if (!statement) {
+      statement = this.db.prepare(sql);
+      if (statements.size >= 128)
+        statements.clear();
+      statements.set(sql, statement);
+    }
+    return statement;
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.pool)
+      this.pool.release(this.connection);
+    else
+      closeConnection(this.connection);
+  }
+  page(sessionID, options = {}) {
+    return trackDecodeOperation("page", () => {
+      const limit = options.limit ?? 100;
+      if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4)
+        throw new Error("Invalid page limit");
+      const after = options.after ?? -1;
+      if (!Number.isSafeInteger(after))
+        throw new Error("Invalid seq cursor");
+      if (options.through !== undefined && !Number.isSafeInteger(options.through))
+        throw new Error("Invalid seq upper bound");
+      const predicates = ["session_id = ?", "seq > ?"];
+      const parameters = [sessionID, after];
+      if (options.through !== undefined) {
+        predicates.push("seq <= ?");
+        parameters.push(options.through);
+      }
+      if (options.type) {
+        predicates.push("type = ?");
+        parameters.push(options.type);
+      }
+      const rows = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                        WHERE ${predicates.join(" AND ")}
+                        ORDER BY seq ASC LIMIT ?`).all(...parameters, limit).map(decode);
+      return { rows, cursor: rows.at(-1)?.seq };
+    });
+  }
+  messagePage(sessionID, afterOrdinal, limit, finalWatermark, after) {
+    return trackDecodeOperation("messagePage", () => {
+      if (!Number.isSafeInteger(afterOrdinal) || afterOrdinal < 0)
+        throw new Error("Invalid raw-message ordinal cursor");
+      if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4)
+        throw new Error("Invalid page limit");
+      if (!Number.isSafeInteger(finalWatermark) || finalWatermark < 0)
+        throw new Error("Invalid raw-message watermark");
+      const pageSize = Math.min(limit, finalWatermark - afterOrdinal);
+      if (pageSize <= 0)
+        return [];
+      if (after) {
+        const anchor = this.prepare("SELECT seq FROM session_message WHERE session_id = ? AND id = ?").get(sessionID, after.id);
+        if (anchor) {
+          return this.prepare(`SELECT id, session_id, type, seq, time_created, data
+                        FROM session_message WHERE session_id = ? AND seq > ?
+                        AND type IN (${RAW_MESSAGE_TYPE_PARAMETERS}) ORDER BY seq ASC LIMIT ?`).all(sessionID, anchor.seq, ...RAW_MESSAGE_TYPES, pageSize).map(decode);
+        }
+      }
+      const maximumSeq = Number.MAX_SAFE_INTEGER;
+      const rows = this.prepare(V2_MESSAGE_PAGE_SQL).all(afterOrdinal, sessionID, ...RAW_MESSAGE_TYPES, Math.max(0, afterOrdinal - 1), sessionID, sessionID, ...RAW_MESSAGE_TYPES, finalWatermark - 1, maximumSeq, sessionID, ...RAW_MESSAGE_TYPES, pageSize);
+      return rows.map(decode);
+    });
+  }
+  messageCount(sessionID) {
+    return trackDecodeOperation("messageCount", () => {
+      const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+      const row = this.prepare(`SELECT COUNT(*) AS count FROM session_message
+                     WHERE session_id = ? AND type IN (${rawTypes})`).get(sessionID, ...RAW_MESSAGE_TYPES);
+      return typeof row?.count === "number" ? row.count : 0;
+    });
+  }
+  messageCountAfterSequence(sessionID, after, through) {
+    const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+    const row = this.prepare(`SELECT COUNT(*) AS count FROM session_message
+             WHERE session_id = ? AND seq > ? AND seq <= ? AND type IN (${rawTypes})`).get(sessionID, after, through, ...RAW_MESSAGE_TYPES);
+    return typeof row?.count === "number" ? row.count : 0;
+  }
+  sessionDirectoryPage(afterSessionID, limit) {
+    const rows = this.prepare(`SELECT id, COALESCE(directory, '') AS directory FROM session_v2
+                 WHERE id > ? ORDER BY id ASC LIMIT ?`).all(afterSessionID ?? "", limit);
+    return rows.map((row) => ({ sessionId: row.id, directory: row.directory }));
+  }
+  latestMessageTime(sessionID) {
+    const row = this.prepare("SELECT MAX(time_created) AS time FROM session_message WHERE session_id = ?").get(sessionID);
+    return row?.time ?? undefined;
+  }
+  isSubagent(sessionID) {
+    const row = this.prepare("SELECT parent_id FROM session_v2 WHERE id = ?").get(sessionID);
+    if (!row)
+      return null;
+    return typeof row.parent_id === "string" && row.parent_id.length > 0;
+  }
+  latestRootSessionInDirectory(directory) {
+    const columns = new Set(this.prepare("PRAGMA table_info(session_v2)").all().map((column) => column.name));
+    const archived = columns.has("time_archived") ? " AND time_archived IS NULL" : "";
+    const order = columns.has("time_updated") ? "time_updated DESC, id DESC" : "id DESC";
+    const page = this.prepare(`SELECT id, COALESCE(directory, '') AS directory FROM session_v2
+                 WHERE parent_id IS NULL${archived}
+                   AND COALESCE(json_extract(metadata, '$.magic_context'), '') <> 'hidden-run'
+                 ORDER BY ${order} LIMIT ? OFFSET ?`);
+    const pageSize = 500;
+    for (let offset = 0;; offset += pageSize) {
+      const rows = page.all(pageSize, offset);
+      const match = rows.find((row) => sameProjectDirectory(row.directory, directory));
+      if (match)
+        return match.id;
+      if (rows.length < pageSize)
+        return;
+    }
+  }
+  rootSessionActivity(sessionIDs) {
+    const roots = new Map;
+    for (let offset = 0;offset < sessionIDs.length; offset += 500) {
+      const chunk = sessionIDs.slice(offset, offset + 500);
+      const rows = this.prepare(`SELECT id, (
+                    SELECT MAX(time_created) FROM session_message
+                    WHERE session_id = session_v2.id AND type = 'user'
+                ) AS time FROM session_v2
+                WHERE parent_id IS NULL
+                  AND COALESCE(json_extract(metadata, '$.magic_context'), '') <> 'hidden-run'
+                  AND id IN (${chunk.map(() => "?").join(",")})`).all(...chunk);
+      for (const row of rows)
+        if (row.time !== null)
+          roots.set(row.id, row.time);
+    }
+    return roots;
+  }
+  oldestUserMessageTimesSince(sessionIDs, sinceMs) {
+    const result = new Map;
+    for (let offset = 0;offset < sessionIDs.length; offset += 500) {
+      const chunk = sessionIDs.slice(offset, offset + 500);
+      const rows = this.prepare(`SELECT session_id, MIN(time_created) AS time FROM session_message
+                WHERE type = 'user' AND time_created > ? AND session_id IN (${chunk.map(() => "?").join(",")})
+                GROUP BY session_id`).all(sinceMs, ...chunk);
+      for (const row of rows)
+        result.set(row.session_id, row.time);
+    }
+    return result;
+  }
+  retrospectiveUserPage(sessionID, options) {
+    const { boundaryMs, before, limit, maxChars, truncationMarker } = options;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4)
+      throw new Error("Invalid page limit");
+    if (!Number.isSafeInteger(maxChars) || maxChars <= truncationMarker.length)
+      throw new Error("Invalid text limit");
+    const direction = before ? "DESC" : "ASC";
+    const head = Math.floor((maxChars - truncationMarker.length) / 2);
+    const tail = maxChars - truncationMarker.length - head;
+    return this.prepare(`WITH users AS (
+            SELECT session_id, seq, time_created, data FROM session_message
+            WHERE session_id = ? AND type = 'user' AND time_created ${before ? "<=" : ">"}
+                ?
+            ORDER BY time_created ${direction}, seq ${direction} LIMIT ?
+        ), texts AS (
+            SELECT session_id, seq, time_created, CASE
+                WHEN json_extract(data, '$.synthetic') = 1 OR json_extract(data, '$.ignored') = 1 THEN ''
+                WHEN json_type(data, '$.text') = 'text' THEN json_extract(data, '$.text')
+                ELSE COALESCE((SELECT group_concat(json_extract(value, '$.text'), char(10))
+                    FROM json_each(users.data, '$.content')
+                    WHERE json_extract(value, '$.type') IN ('text', 'input_text')
+                      AND COALESCE(json_extract(value, '$.synthetic'), 0) <> 1
+                      AND COALESCE(json_extract(value, '$.ignored'), 0) <> 1), '') END AS text
+            FROM users WHERE json_valid(data)
+        ) SELECT seq, time_created, CASE WHEN length(text) > ?
+            THEN substr(text, 1, ?) || ? || substr(text, -?) ELSE text END AS text,
+            EXISTS (
+                SELECT 1 FROM session_message assistant_reply
+                 WHERE assistant_reply.session_id = texts.session_id
+                   AND assistant_reply.type = 'assistant'
+                   AND assistant_reply.seq < texts.seq
+                   AND EXISTS (
+                       SELECT 1 FROM session_message prior_user
+                        WHERE prior_user.session_id = texts.session_id
+                          AND prior_user.type = 'user'
+                          AND prior_user.seq < assistant_reply.seq
+                   )
+            ) AS follows_assistant_reply
+          FROM texts ORDER BY time_created ${direction}, seq ${direction}`).all(sessionID, boundaryMs, limit, maxChars, head, truncationMarker, tail);
+  }
+  storedRowsAfter(sessionID, after) {
+    const row = this.prepare("SELECT COUNT(*) AS count FROM session_message WHERE session_id = ? AND seq > ?").get(sessionID, after);
+    return row.count;
+  }
+  storedMessageCount(sessionID) {
+    return trackDecodeOperation("storedMessageCount", () => {
+      const row = this.prepare("SELECT COUNT(*) AS count FROM session_message WHERE session_id = ?").get(sessionID);
+      return typeof row?.count === "number" ? row.count : 0;
+    });
+  }
+  messageById(sessionID, id) {
+    return trackDecodeOperation("messageById", () => {
+      const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+      const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                     WHERE session_id = ? AND id = ? AND type IN (${rawTypes}) LIMIT 1`).get(sessionID, id, ...RAW_MESSAGE_TYPES);
+      return row ? decode(row) : null;
+    });
+  }
+  messageTimes(sessionID, ids) {
+    const times = new Map;
+    for (let offset = 0;offset < ids.length; offset += 500) {
+      const batch = ids.slice(offset, offset + 500);
+      const rows = this.prepare(messageTimesQuery(batch.length)).all(sessionID, ...batch);
+      for (const row of rows)
+        times.set(row.id, {
+          created: typeof row.created === "number" ? row.created : undefined,
+          completed: typeof row.completed === "number" ? row.completed : undefined
+        });
+    }
+    return times;
+  }
+  messageExistsById(sessionID, id) {
+    return trackDecodeOperation("messageExistsById", () => {
+      const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+      const row = this.prepare(`SELECT 1 FROM session_message
+                     WHERE id = ? AND session_id = ? AND type IN (${rawTypes}) LIMIT 1`).get(id, sessionID, ...RAW_MESSAGE_TYPES);
+      return row != null;
+    });
+  }
+  messageOrdinalById(sessionID, id) {
+    return trackDecodeOperation("messageOrdinalById", () => {
+      const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+      const row = this.prepare(`WITH target AS (
+                        SELECT seq FROM session_message
+                        WHERE session_id = ? AND id = ? AND type IN (${rawTypes})
+                        LIMIT 1
+                    )
+                    SELECT (
+                        SELECT COUNT(*) FROM session_message
+                        WHERE session_id = ?
+                          AND type IN (${rawTypes})
+                          AND seq <= target.seq
+                    ) AS ordinal
+                    FROM target`).get(sessionID, id, ...RAW_MESSAGE_TYPES, sessionID, ...RAW_MESSAGE_TYPES);
+      return typeof row?.ordinal === "number" ? row.ordinal : null;
+    });
+  }
+  messageIdOrdinals(sessionID, fromOrdinal, toOrdinal) {
+    return trackDecodeOperation("messageIdOrdinals", () => {
+      if (!Number.isSafeInteger(fromOrdinal) || fromOrdinal < 1)
+        throw new Error("Invalid raw-message range start");
+      if (!Number.isSafeInteger(toOrdinal) || toOrdinal < fromOrdinal)
+        throw new Error("Invalid raw-message range end");
+      const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+      const rows = this.prepare(`SELECT id FROM session_message
+                     WHERE session_id = ? AND type IN (${rawTypes})
+                     ORDER BY seq ASC LIMIT ? OFFSET ?`).all(sessionID, ...RAW_MESSAGE_TYPES, toOrdinal - fromOrdinal + 1, fromOrdinal - 1);
+      return new Map(rows.map((row, index) => [row.id, fromOrdinal + index]));
+    });
+  }
+  messageOrdinalPage(sessionID, after, limit) {
+    return trackDecodeOperation("messageOrdinalPage", () => {
+      if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4)
+        throw new Error("Invalid page limit");
+      const rows = after ? this.prepare(`SELECT id, type, seq, json_valid(data) AS valid
+                               FROM session_message
+                               WHERE session_id = ? AND (seq > ? OR (seq = ? AND id > ?))
+                               ORDER BY seq ASC, id ASC LIMIT ?`).all(sessionID, after.timeCreated, after.timeCreated, after.id, limit) : this.prepare(`SELECT id, type, seq, json_valid(data) AS valid
+                               FROM session_message
+                               WHERE session_id = ?
+                               ORDER BY seq ASC, id ASC LIMIT ?`).all(sessionID, limit);
+      const rawTypes = new Set(RAW_MESSAGE_TYPES);
+      return rows.map((row) => ({
+        id: row.id,
+        timeCreated: row.seq,
+        contributesOrdinal: rawTypes.has(row.type),
+        hasValidInfo: row.valid === 1
+      }));
+    });
+  }
+  range(sessionID, after, through) {
+    return trackDecodeOperation("range", () => through <= after ? [] : this.all(sessionID, after, undefined, through));
+  }
+  spanRowStamps(sessionID, after, through) {
+    if (!Number.isSafeInteger(after) || !Number.isSafeInteger(through))
+      throw new Error("Invalid seq span");
+    const rows = this.prepare(`SELECT seq, id, time_updated AS updated, length(CAST(data AS BLOB)) AS bytes
+                 FROM session_message WHERE session_id = ? AND seq > ? AND seq <= ?
+                 ORDER BY seq ASC`).all(sessionID, after, through);
+    const stamps = new Map;
+    for (const row of rows)
+      stamps.set(row.seq, `${row.id}\x00${row.updated ?? ""}\x00${row.bytes ?? ""}`);
+    return stamps;
+  }
+  rawRowsThrough(sessionID, throughSeq, limit) {
+    return trackDecodeOperation("rawRowsThrough", () => {
+      if (!Number.isSafeInteger(throughSeq))
+        throw new Error("Invalid seq upper bound");
+      if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4)
+        throw new Error("Invalid page limit");
+      const rawTypes = RAW_MESSAGE_TYPES.map(() => "?").join(", ");
+      return this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                         WHERE session_id = ? AND type IN (${rawTypes}) AND seq <= ?
+                         ORDER BY seq DESC LIMIT ?`).all(sessionID, ...RAW_MESSAGE_TYPES, throughSeq, limit).map(decode);
+    });
+  }
+  instructionRowsThrough(sessionID, throughSeq) {
+    return trackDecodeOperation("instructionRowsThrough", () => {
+      if (!Number.isSafeInteger(throughSeq))
+        throw new Error("Invalid seq upper bound");
+      return this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                         WHERE session_id = ? AND type = 'system' AND seq <= ?
+                         ORDER BY seq ASC`).all(sessionID, throughSeq).map(decode);
+    });
+  }
+  sequenceForId(sessionID, id) {
+    if (!id)
+      return;
+    const row = this.prepare("SELECT seq FROM session_message WHERE session_id = ? AND id = ? LIMIT 1").get(sessionID, id);
+    return typeof row?.seq === "number" ? row.seq : undefined;
+  }
+  syntheticMessageIDs(sessionID) {
+    const rows = this.prepare("SELECT id FROM session_message WHERE session_id = ? AND type = 'synthetic'").all(sessionID);
+    return new Set(rows.map((row) => row.id));
+  }
+  forkOrigin(sessionID) {
+    const columns = new Set(this.prepare("PRAGMA table_info(session_v2)").all().map((column) => column.name));
+    if (!columns.has("fork_session_id") || !columns.has("fork_boundary"))
+      return null;
+    const row = this.prepare("SELECT fork_session_id, fork_boundary FROM session_v2 WHERE id = ?").get(sessionID);
+    if (!row?.fork_session_id || !row.fork_boundary)
+      return null;
+    try {
+      const boundary = JSON.parse(row.fork_boundary);
+      if (boundary.type !== "before" && boundary.type !== "through" || typeof boundary.messageID !== "string" || boundary.messageID.length === 0)
+        return null;
+      return {
+        parentSessionID: row.fork_session_id,
+        boundary: { type: boundary.type, messageID: boundary.messageID }
+      };
+    } catch {
+      return null;
+    }
+  }
+  sessionExists(sessionID) {
+    return this.prepare("SELECT 1 FROM session_v2 WHERE id = ?").get(sessionID) != null;
+  }
+  rowStampsThrough(sessionID, throughSeq) {
+    return this.prepare(`SELECT id, type, seq, time_created FROM session_message
+                 WHERE session_id = ? AND seq <= ? ORDER BY seq ASC`).all(sessionID, throughSeq);
+  }
+  latestSequenceForIds(sessionID, ids) {
+    let latest = -1;
+    for (let offset = 0;offset < ids.length; offset += 500) {
+      const chunk = ids.slice(offset, offset + 500);
+      const row = this.prepare(`SELECT MAX(seq) AS seq FROM session_message
+                     WHERE session_id = ? AND id IN (${chunk.map(() => "?").join(", ")})`).get(sessionID, ...chunk);
+      if (typeof row?.seq === "number")
+        latest = Math.max(latest, row.seq);
+    }
+    return latest;
+  }
+  compactionByStatus(sessionID, status) {
+    const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                WHERE session_id = ? AND type = 'compaction'
+                  AND json_extract(data, '$.status') = ?
+                ORDER BY seq DESC LIMIT 1`).get(sessionID, status);
+    return row ? decode(row) : undefined;
+  }
+  latestCompaction(sessionID) {
+    return trackDecodeOperation("latestCompaction", () => this.compactionByStatus(sessionID, "completed"));
+  }
+  latestRunningCompaction(sessionID) {
+    return trackDecodeOperation("latestRunningCompaction", () => this.compactionByStatus(sessionID, "running"));
+  }
+  idleRows(sessionID, after = -1) {
+    return trackDecodeOperation("idleRows", () => this.all(sessionID, after, "idle"));
+  }
+  earliestSequence(sessionID) {
+    const row = this.prepare("SELECT MIN(seq) AS seq FROM session_message WHERE session_id = ?").get(sessionID);
+    return typeof row?.seq === "number" ? row.seq : undefined;
+  }
+  latestSequence(sessionID) {
+    const row = this.prepare("SELECT MAX(seq) AS seq FROM session_message WHERE session_id = ?").get(sessionID);
+    return typeof row?.seq === "number" ? row.seq : -1;
+  }
+  assistantSince(sessionID, afterSeq) {
+    return trackDecodeOperation("assistantSince", () => {
+      const rows = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                    WHERE session_id = ? AND type = 'assistant' AND seq > ?
+                    ORDER BY seq ASC`).all(sessionID, afterSeq);
+      return rows.map((row) => decode(row));
+    });
+  }
+  latestAssistant(sessionID) {
+    return trackDecodeOperation("latestAssistant", () => {
+      const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                    WHERE session_id = ? AND type = 'assistant'
+                    ORDER BY seq DESC LIMIT 1`).get(sessionID);
+      return row ? decode(row) : undefined;
+    });
+  }
+  latestIdle(sessionID) {
+    return trackDecodeOperation("latestIdle", () => {
+      const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                    WHERE session_id = ? AND type = 'idle'
+                    ORDER BY seq DESC LIMIT 1`).get(sessionID);
+      return row ? decode(row) : undefined;
+    });
+  }
+  window(sessionID) {
+    return trackDecodeOperation("window", () => this.db.transaction(() => {
+      const cut = this.latestCompaction(sessionID);
+      return this.all(sessionID, cut ? cut.seq - 1 : -1);
+    }).deferred());
+  }
+  history(sessionID) {
+    return trackDecodeOperation("history", () => this.all(sessionID, -1));
+  }
+  all(sessionID, after, type, through) {
+    const rows = [];
+    for (;; ) {
+      const page = this.page(sessionID, { after, through, type });
+      rows.push(...page.rows);
+      if (page.rows.length < 100 || page.cursor === undefined)
+        return rows;
+      after = page.cursor;
+    }
+  }
+}
+
 // src/features/magic-context/resolve-subagent-fallback.ts
 function resolveIsSubagentFromOpenCodeDb(sessionId) {
   try {
@@ -5027,6 +6243,142 @@ function resolveIsSubagentFromOpenCode2Db(sessionId) {
   }
 }
 
+// src/features/magic-context/storage-session-tables.ts
+var SESSION_SCOPED_TABLES = [
+  { table: "pending_ops", harnessScoped: true },
+  { table: "source_contents", harnessScoped: true },
+  { table: "tool_owner_backfill_state" },
+  { table: "tags", harnessScoped: true },
+  { table: "session_meta", harnessScoped: true },
+  {
+    table: "temporal_decisions",
+    extraPredicate: "NOT EXISTS (SELECT 1 FROM session_meta AS remaining WHERE remaining.session_id = temporal_decisions.session_id)"
+  },
+  {
+    table: "session_replay_decisions",
+    extraPredicate: "NOT EXISTS (SELECT 1 FROM session_meta AS remaining WHERE remaining.session_id = session_replay_decisions.session_id)"
+  },
+  { table: "session_projects", harnessScoped: true },
+  { table: "compartment_chunk_embeddings", harnessScoped: true },
+  { table: "compartments", harnessScoped: true },
+  {
+    table: "compartment_history_versions",
+    extraPredicate: "NOT EXISTS (SELECT 1 FROM compartments AS remaining WHERE remaining.session_id = compartment_history_versions.session_id)"
+  },
+  { table: "compression_depth", harnessScoped: true },
+  { table: "session_facts", harnessScoped: true },
+  { table: "compartment_state_lease" },
+  { table: "notes", harnessScoped: true, extraPredicate: "type = 'session'" },
+  { table: "recomp_compartments", harnessScoped: true },
+  { table: "recomp_facts", harnessScoped: true },
+  { table: "user_memory_candidates" },
+  { table: "primer_candidates", harnessScoped: true },
+  { table: "m0_mutation_log" },
+  { table: "compartment_events", harnessScoped: true },
+  { table: "subagent_invocations", harnessScoped: true },
+  { table: "historian_runs", harnessScoped: true },
+  { table: "plugin_messages" },
+  { table: "transform_decisions", harnessScoped: true },
+  { table: "synapse_batch_ledger" },
+  { table: "embedding_measurement_corpus" },
+  { table: "pending_session_cleanup", harnessScoped: true },
+  { table: "message_history_fts" },
+  { table: "message_fts_rowid_map" },
+  { table: "message_history_source", harnessScoped: true },
+  { table: "message_history_index", harnessScoped: true },
+  { table: "lkg_slots" },
+  { table: "lkg_slot_chunks" }
+];
+var cleanupStatements = new WeakMap;
+function cleanupStatement(db, sql) {
+  let cache = cleanupStatements.get(db);
+  if (!cache) {
+    cache = new Map;
+    cleanupStatements.set(db, cache);
+  }
+  let statement = cache.get(sql);
+  if (!statement) {
+    if (cache.size >= 256)
+      cache.clear();
+    statement = prepareCachedStatement2(db, sql);
+    cache.set(sql, statement);
+  }
+  return statement;
+}
+function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
+  if (sessionIds.length === 0)
+    return 0;
+  let deletableSessionIds = [...sessionIds];
+  if (options.rustModuleCleanupAcknowledged !== true) {
+    const placeholders = sessionIds.map(() => "?").join(", ");
+    const harnessPredicate = harness === undefined ? "" : " AND harness = ?";
+    const protectedRows = cleanupStatement(db, `SELECT session_id
+                 FROM pending_session_cleanup
+                 WHERE session_id IN (${placeholders})
+                   AND harness LIKE '%:rust'${harnessPredicate}`).all(...sessionIds, ...harness === undefined ? [] : [`${harness}:rust`]);
+    const protectedSessionIds = new Set(protectedRows.map((row) => row.session_id));
+    deletableSessionIds = sessionIds.filter((sessionId) => !protectedSessionIds.has(sessionId));
+  }
+  if (deletableSessionIds.length === 0)
+    return 0;
+  const placeholders = deletableSessionIds.map(() => "?").join(", ");
+  const harnessTables = SESSION_SCOPED_TABLES.filter((definition) => definition.harnessScoped);
+  if (options.preserveTagRevisionTombstones) {
+    const owners = cleanupStatement(db, harnessTables.map((definition) => `SELECT session_id, harness FROM ${definition.table} WHERE session_id IN (${placeholders})${definition.extraPredicate ? ` AND ${definition.extraPredicate}` : ""}`).join(" UNION ")).all(...harnessTables.flatMap(() => deletableSessionIds));
+    const record = cleanupStatement(db, "INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, ?)");
+    for (const owner of owners)
+      record.run(tagTombstoneOwnerKey(owner.session_id, owner.harness), owner.harness);
+    const fallback = cleanupStatement(db, `INSERT INTO schema_migrations_meta (key, value)
+            SELECT ?, ? WHERE NOT EXISTS (SELECT 1 FROM schema_migrations_meta WHERE key >= ? AND key < ?)`);
+    for (const id of deletableSessionIds)
+      fallback.run(tagTombstoneOwnerKey(id, getHarness2()), getHarness2(), ...tagTombstoneOwnerRange(id));
+  }
+  for (const sessionId of deletableSessionIds)
+    deleteChunkEmbedBackoffForSession2(db, sessionId);
+  for (const definition of SESSION_SCOPED_TABLES) {
+    if (definition.table === "message_history_fts") {
+      cleanupStatement(db, `DELETE FROM message_history_fts
+                 WHERE rowid IN (
+                     SELECT fts_rowid
+                     FROM message_fts_rowid_map
+                     WHERE session_id IN (${placeholders})
+                 )`).run(...deletableSessionIds);
+      deleteUnmappedMessageFtsRows2(db, deletableSessionIds);
+      continue;
+    }
+    const predicates = [`session_id IN (${placeholders})`];
+    if (definition.extraPredicate)
+      predicates.push(definition.extraPredicate);
+    const bindHarness = harness !== undefined && definition.harnessScoped === true;
+    if (bindHarness)
+      predicates.push("harness = ?");
+    const statement = cleanupStatement(db, `DELETE FROM ${definition.table} WHERE ${predicates.join(" AND ")}`);
+    if (bindHarness)
+      statement.run(...deletableSessionIds, harness);
+    else
+      statement.run(...deletableSessionIds);
+  }
+  deleteSessionActivity(db, deletableSessionIds);
+  if (!options.preserveTagRevisionTombstones) {
+    const retireOwner = cleanupStatement(db, harness === undefined ? "DELETE FROM schema_migrations_meta WHERE key >= ? AND key < ?" : "DELETE FROM schema_migrations_meta WHERE key = ?");
+    const survivingRows = harnessTables.map((definition) => `EXISTS (SELECT 1 FROM ${definition.table} WHERE session_id = ?${definition.extraPredicate ? ` AND ${definition.extraPredicate}` : ""})`).join(" OR ");
+    const retire = cleanupStatement(db, `DELETE FROM schema_migrations_meta WHERE key IN (?, ?)
+            AND NOT (${survivingRows})
+            AND NOT EXISTS (SELECT 1 FROM schema_migrations_meta AS owners WHERE owners.key >= ? AND owners.key < ?)`);
+    for (const id of deletableSessionIds) {
+      if (harness === undefined)
+        retireOwner.run(...tagTombstoneOwnerRange(id));
+      else
+        retireOwner.run(tagTombstoneOwnerKey(id, harness));
+      retire.run(tagIdentityRevisionKey(id), tagRevisionKey(id), ...harnessTables.map(() => id), ...tagTombstoneOwnerRange(id));
+    }
+  }
+  if (!options.deferRecoveryFenceCleanup)
+    for (const sessionId of deletableSessionIds)
+      clearLkgRecoveryFence(sessionId);
+  return deletableSessionIds.length;
+}
+
 // src/features/magic-context/storage-meta-session.ts
 var SESSION_META_FALLBACK_SELECTS = {
   cache_ttl: "'5m' AS cache_ttl",
@@ -5280,7 +6632,7 @@ function hasOnlySystemHashMaterialization(sessions, sessionId) {
 }
 
 // src/hooks/magic-context/system-prompt-delivery.ts
-var pending2 = new BoundedSessionMap(1000);
+var pending3 = new BoundedSessionMap(1000);
 var retiredRequests = new WeakSet;
 var heldRequests = new WeakSet;
 var refreshOwners = new BoundedSessionMap(1000);
@@ -5296,11 +6648,11 @@ function recordSystemRefreshOwnership(sessionId, hash, ownsHistoryRefresh, histo
 function preparation(sessionId, request) {
   if (retiredRequests.has(request))
     return;
-  const previous = pending2.get(sessionId);
+  const previous = pending3.get(sessionId);
   if (previous?.request === request)
     return previous;
   const next = { request, held: false };
-  pending2.set(sessionId, next);
+  pending3.set(sessionId, next);
   return next;
 }
 function recordSystemPromptForRequest(sessionId, request, hash, db, ownsHistoryRefresh, history, materialization) {
@@ -5308,7 +6660,7 @@ function recordSystemPromptForRequest(sessionId, request, hash, db, ownsHistoryR
     return;
   if (ownsHistoryRefresh !== undefined)
     recordSystemRefreshOwnership(sessionId, hash, ownsHistoryRefresh, history, materialization);
-  const previous = pending2.get(sessionId);
+  const previous = pending3.get(sessionId);
   if (previous?.request === request && previous.held && previous.hash && previous.hash !== hash) {
     retirePendingSystemPromptDelivery(sessionId);
     return;
@@ -5331,7 +6683,7 @@ function recordHeldHeadForRequest(sessionId, request, deferRefresh) {
   }
 }
 function bindSystemPromptResponse(sessionId, request, response) {
-  const saved = pending2.get(sessionId);
+  const saved = pending3.get(sessionId);
   if (!saved || saved.request !== request || request?.kind !== "v2" || !response.responseId || response.responseId === request.previousResponseId || response.modelKey !== request.modelKey || !Number.isFinite(response.createdAt) || response.createdAt <= request.startedAt)
     return;
   if (saved.response && saved.response.id !== response.responseId)
@@ -5339,11 +6691,11 @@ function bindSystemPromptResponse(sessionId, request, response) {
   saved.response = { id: response.responseId, createdAt: response.createdAt };
 }
 function isHeldHeadForRequest(sessionId, request) {
-  const saved = pending2.get(sessionId);
+  const saved = pending3.get(sessionId);
   return saved?.request === request && saved?.held === true || request !== undefined && retiredRequests.has(request) && heldRequests.has(request);
 }
 function acknowledgeSystemPromptDelivery(args) {
-  const saved = pending2.get(args.sessionId);
+  const saved = pending3.get(args.sessionId);
   if (!saved || saved.request !== args.request || !args.responseId)
     return;
   const request = saved.request;
@@ -5385,10 +6737,10 @@ function clearSystemPromptDelivery(sessionId) {
   refreshOwners.delete(sessionId);
 }
 function retirePendingSystemPromptDelivery(sessionId) {
-  const saved = pending2.get(sessionId);
+  const saved = pending3.get(sessionId);
   if (saved)
     retiredRequests.add(saved.request);
-  pending2.delete(sessionId);
+  pending3.delete(sessionId);
 }
 
 // src/hooks/magic-context/lkg-measured-request.ts
@@ -5400,7 +6752,7 @@ function lkgProviderInputTotal(tokens) {
   return counts.every((count) => Number.isSafeInteger(count) && count >= 0) ? counts.reduce((sum, count) => sum + count, 0) : Number.NaN;
 }
 function identity(slot) {
-  return createHash3("sha256").update(JSON.stringify([
+  return createHash6("sha256").update(JSON.stringify([
     slot.capturedAt,
     slot.captureSequence,
     slot.rowVersion,
@@ -5496,7 +6848,7 @@ function clearCapturedLkgMeasurement(sessionId) {
 }
 
 // src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function parseStringArray(value) {
   if (typeof value !== "string")
     return null;
@@ -5610,7 +6962,7 @@ function rememberFingerprint(db, sessionId, fingerprint) {
   saved.set(sessionId, fingerprint);
 }
 function slotFingerprint(slot) {
-  return createHash4("sha256").update(JSON.stringify([
+  return createHash7("sha256").update(JSON.stringify([
     slot.jsonPrefix,
     slot.inputIdSeq,
     slot.inputContentDigests,
@@ -6758,7 +8110,7 @@ var DIGEST_CHUNK_BYTES = 64 * 1024;
 var digestChunk;
 function lkgContentDigestFromFields(fields) {
   lkgDigestsComputed += 1;
-  const hash = createHash5("sha256");
+  const hash = createHash8("sha256");
   digestChunk ??= Buffer.allocUnsafe(DIGEST_CHUNK_BYTES);
   const chunk = digestChunk;
   let offset = 0;
@@ -6821,7 +8173,7 @@ function legacyLkgDigestFromFields(fields) {
     const value = typeof field === "symbol" ? field.description ?? "" : String(field);
     key += `${typeof field}:${value.length}:${value}\x00`;
   }
-  return createHash5("sha256").update(key).digest("base64url");
+  return createHash8("sha256").update(key).digest("base64url");
 }
 function legacyLkgContentDigest(message) {
   const fields = flattenContentFields(withoutEmptyUserDiffSummary(message));
@@ -7391,15 +8743,15 @@ function createPreAdoptionToolSweepResolver(db, sessionId) {
 }
 
 // src/features/magic-context/pi-content-decisions.ts
-var PREFIX = "pi-content-replay-v1:";
+var PREFIX2 = "pi-content-replay-v1:";
 function encodePiContentDecision(kind, messageId) {
-  return PREFIX + JSON.stringify([kind, messageId]);
+  return PREFIX2 + JSON.stringify([kind, messageId]);
 }
 function decodePiContentDecision(value) {
-  if (!value.startsWith(PREFIX))
+  if (!value.startsWith(PREFIX2))
     return null;
   try {
-    const pair = JSON.parse(value.slice(PREFIX.length));
+    const pair = JSON.parse(value.slice(PREFIX2.length));
     if (Array.isArray(pair) && pair.length === 2 && (pair[0] === "reminder-strip" || pair[0] === "seam-temporal-strip" || pair[0] === "tag-identity-repair-once" || pair[0] === "tag-identity-repair-pending" || pair[0] === "tag-identity-rebuild-failed" || pair[0] === "tag-identity-recurring") && typeof pair[1] === "string" && pair[1].length > 0)
       return [pair[0], pair[1]];
   } catch {}
@@ -8294,7 +9646,7 @@ class HiddenCompletionRefusal extends Error {
 }
 // src/features/magic-context/dreamer/provider-output-failure.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 var MAX_NEAR_ZERO_OUTPUT_TOKENS = 32;
 
 class DreamerProviderOutputFailureError extends Error {
@@ -8391,12 +9743,12 @@ function providerOutputFailureFromInvalidManifest(messages, responseText, now =
   const resetAt = quotaResetAt(responseText, now);
   if (resetAt === undefined && completion.outputTokens > MAX_NEAR_ZERO_OUTPUT_TOKENS)
     return null;
-  const fingerprint = createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
+  const fingerprint = createHash9("sha256").update(normalized).digest("hex").slice(0, 16);
   return new DreamerProviderOutputFailureError(fingerprint, completion.outputTokens, completion.reasoningTokens, responseText, resetAt);
 }
 
 // src/v2/hooks/hidden-child.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // src/shared/historian-cache.ts
 function withoutHistorianTailCache(body) {
@@ -8593,7 +9945,7 @@ function markerCandidates(text) {
 function textDigest(text) {
   return {
     length: text.length,
-    sha256: createHash7("sha256").update(text).digest("hex").slice(0, 16)
+    sha256: createHash10("sha256").update(text).digest("hex").slice(0, 16)
   };
 }
 function firstDifference(a, b) {
@@ -10063,9 +11415,9 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
   }
 }
 // src/shared/prompt-surface-runtime.ts
-import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, resolve as resolve2 } from "node:path";
+import { createHash as createHash11 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
 
 // src/tools/light-descriptions.ts
 var CTX_REDUCE_LIGHT_DESCRIPTION = `Stamp an item as no longer needed for the work ahead. Not a delete: stamping QUEUES it, the item stays readable until Magic Context clears stamped items in one sweep, newest tags are protected, and a cleared item goes to the archive (recent: a [dropped §N§] placeholder; older: removed) recoverable via ctx_expand(tag=N). The question is "does this need to stay on my desk for what comes next?" — a file you keep editing stays, the grep that found it goes. Stamp used reads/searches/outputs, acted-on build/test output, redundant dumps, extracted pasted payloads; keep user messages, your own text, unresolved errors, raw evidence, exact wording that may matter. Look at each tag; never blanket-stamp "1-50". Grammar: "3-5", "1,2,9", "1-5,8,12-15".`;
@@ -10096,22 +11448,22 @@ function promptSurfaceHashMaterial(systemContent, preset = "full") {
 \x00magic-context-prompt-surface:${preset}`;
 }
 function systemPromptFingerprint(systemContent, preset = "full") {
-  return createHash8("md5").update(promptSurfaceHashMaterial(systemContent, preset)).digest("hex");
+  return createHash11("md5").update(promptSurfaceHashMaterial(systemContent, preset)).digest("hex");
 }
 var PROMPT_SURFACE_TOOL_ID_SET = new Set(ACTIVE_TOOL_IDS);
 function resolveUserConfigDirectory(options) {
   if (options.userConfigDirectory)
-    return resolve2(options.userConfigDirectory);
+    return resolve3(options.userConfigDirectory);
   const sharedBase = cortexKitUserConfigBasePath();
   const shared = detectConfigFile(sharedBase);
   if (shared.format !== "none")
-    return dirname4(shared.path);
+    return dirname5(shared.path);
   if (options.harness) {
     const legacy = resolveLegacyConfigSourcesForHarness(options.directory ?? process.cwd(), options.harness === "omp" ? "pi" : options.harness === "opencode2" ? "opencode" : options.harness).user.find((source) => existsSync5(source.path));
     if (legacy)
-      return dirname4(legacy.path);
+      return dirname5(legacy.path);
   }
-  return dirname4(sharedBase);
+  return dirname5(sharedBase);
 }
 function markerCount(content) {
   return content.match(GUIDANCE_MARKER_LINE)?.length ?? 0;
@@ -10128,14 +11480,14 @@ function createPromptSurfaceRuntime(options) {
   const readGuidanceOverride = (configuredPath) => {
     if (!configuredPath)
       return;
-    const path = isAbsolute3(configuredPath) ? configuredPath : resolve2(userConfigDirectory, configuredPath);
+    const path = isAbsolute3(configuredPath) ? configuredPath : resolve3(userConfigDirectory, configuredPath);
     let content;
     try {
-      if (!statSync5(path).isFile()) {
+      if (!statSync6(path).isFile()) {
         warnOnce(`guidance-not-file:${path}`, `prompt_surface.guidance_override_path (${path}) is not a file; using built-in guidance.`);
         return;
       }
-      content = readFileSync6(path, "utf8");
+      content = readFileSync8(path, "utf8");
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
       warnOnce(`guidance-unreadable:${path}:${reason}`, `prompt_surface.guidance_override_path (${path}) could not be read (${reason}); using built-in guidance.`);
@@ -10284,7 +11636,7 @@ function parseFields(json) {
 
 // src/hooks/magic-context/compartment-runner-historian.ts
 import { mkdirSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/agents/historian.ts
 var HISTORIAN_AGENT = "historian";
@@ -10782,7 +12134,7 @@ function compareMemorySelectionPriority(left, right) {
 }
 
 // src/features/magic-context/mural/render-trigger.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/features/magic-context/mural/mural-selection.ts
 var DEFAULT_MURAL_MEMORY_BUDGET = 8000;
@@ -11486,7 +12838,7 @@ function ensureMuralRendered(db, projectIdentity, budgetTokens = DEFAULT_MURAL_M
     return { ...cached.result };
   }
   const plan = planMuralRender(entries);
-  const textHash = createHash9("sha256").update(plan.layout.text).digest("hex");
+  const textHash = createHash12("sha256").update(plan.layout.text).digest("hex");
   if (existing && existing.contentHash === textHash && existing.width === plan.width && existing.height === plan.height) {
     return rememberRender(db, projectIdentity, key, existing.image, {
       hasMural: true,
@@ -11675,14 +13027,14 @@ function parseUserMemoryRow(row) {
 }
 
 // src/features/magic-context/compaction-marker.ts
-import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync6, statSync as statSync6 } from "node:fs";
+import { createHash as createHash13 } from "node:crypto";
+import { existsSync as existsSync6, statSync as statSync7 } from "node:fs";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var ID_PREFIX_HEX_LENGTH = 12;
 var ID_SUFFIX_LENGTH = 14;
 var ID_PREFIX_MASK = (1n << BigInt(ID_PREFIX_HEX_LENGTH * 4)) - 1n;
 function deterministicBase62(seed, length) {
-  let value = BigInt(`0x${createHash10("sha256").update(seed).digest("hex")}`);
+  let value = BigInt(`0x${createHash13("sha256").update(seed).digest("hex")}`);
   const chars = Array(length);
   for (let index = length - 1;index >= 0; index -= 1) {
     chars[index] = BASE62_CHARS[Number(value % 62n)];
@@ -11748,7 +13100,7 @@ function runMarkerWriteTransaction(db, site, operation) {
 function markerWalPages(db) {
   try {
     const row = db.prepare("PRAGMA page_size").get();
-    const bytes = statSync6(`${getOpenCodeDbPath()}-wal`).size;
+    const bytes = statSync7(`${getOpenCodeDbPath()}-wal`).size;
     return Math.max(0, Math.floor((bytes - 32) / (row.page_size + 24)));
   } catch {
     return null;
@@ -18064,7 +19416,7 @@ function dumpHistorianResponse(sessionId, directory, label, text) {
     ensureCortexKitArtifactGitignore(directory);
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join3(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join5(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync2(dumpPath, text, "utf8");
     sessionLog2(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -18277,7 +19629,7 @@ function addToProjection(projection, messages, withIndexSources) {
     if (isStrictGapHealingMessage2(message))
       projection.nonNarrativeOrdinals.add(message.ordinal);
     if (withIndexSources)
-      projection.indexSources.push(toMessageIndexSource2(message));
+      projection.indexSources.push(toMessageIndexSource(message));
   }
   projection.messageCount += messages.length;
 }
@@ -18644,7 +19996,7 @@ function* rebaseSteps(args) {
       outcome.recompPartialRangeRebased = true;
     }
     if (indexNeedsRebuild) {
-      clearIndexedMessagesInTransaction2(db, sessionId);
+      clearIndexedMessagesInTransaction(db, sessionId);
       outcome.indexRebuilt = true;
       outcome.compressionDepthRowsDropped = depthRowCount;
     }
@@ -18682,7 +20034,7 @@ function* rebaseSteps(args) {
   if (outcome.indexRebuilt) {
     const sources = projection.indexSources;
     for (let start = 0;start < sources.length; start += INDEX_REBUILD_CHUNK) {
-      indexSourcesAfterOrdinal2(db, sessionId, sources.slice(start, start + INDEX_REBUILD_CHUNK), sources.length);
+      indexSourcesAfterOrdinal(db, sessionId, sources.slice(start, start + INDEX_REBUILD_CHUNK), sources.length);
       yield;
     }
     outcome.indexRowsRebuilt = countRows2(db, "SELECT COUNT(*) AS count FROM message_history_source WHERE session_id = ?", sessionId);
@@ -18874,6 +20226,60 @@ function queueDropsForCompartmentalizedMessages(db, sessionId, upToMessageIndex,
   queuePreparedCompartmentDrops(db, prepareCompartmentDrops(db, sessionId, upToMessageIndex, observedKeys, fromMessageIndex));
 }
 
+// src/hooks/magic-context/historian-history-wait.ts
+var historyWaits = new Map;
+function newestMessageId(snapshot) {
+  try {
+    const count = getRawSessionMessageOrdinalCount2(snapshot.sessionId);
+    const ids = readRawSessionMessageIdOrdinalsForRange2(snapshot.sessionId, count, count);
+    const newest = ids.keys().next().value;
+    if (newest)
+      return newest;
+  } catch {}
+  return snapshot.rawLastMessageIdAtTrigger;
+}
+function recoveryWindow(snapshot, percentage) {
+  return percentage >= escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage || snapshot.emergencyTailScale !== undefined;
+}
+function clearHistorianHistoryWait(sessionId) {
+  historyWaits.delete(sessionId);
+}
+function recordHistorianNoProgress(snapshot, emergency = false) {
+  const newest = newestMessageId(snapshot);
+  if (!newest)
+    return;
+  const previous = historyWaits.get(snapshot.sessionId);
+  const sameHistory = previous?.newestMessageId === newest;
+  historyWaits.set(snapshot.sessionId, {
+    newestMessageId: newest,
+    recoveryAttempted: sameHistory && previous.recoveryAttempted || emergency || recoveryWindow(snapshot, snapshot.usagePercentage),
+    floorLiftAttempted: sameHistory && previous.floorLiftAttempted || snapshot.liftLivePromptFloor === true
+  });
+}
+function shouldWaitForNewHistorianHistory(snapshot, options = {}) {
+  const wait = historyWaits.get(snapshot.sessionId);
+  if (!wait)
+    return false;
+  const newest = newestMessageId(snapshot);
+  if (newest && newest !== wait.newestMessageId) {
+    try {
+      const order = compareRawSessionMessageOrder2(snapshot.sessionId, newest, wait.newestMessageId);
+      if (order === null || order > 0)
+        return false;
+    } catch {}
+  }
+  const recovery = options.emergency || recoveryWindow(snapshot, options.usagePercentage ?? snapshot.usagePercentage);
+  const floorLift = snapshot.liftLivePromptFloor === true;
+  if (recovery && !wait.recoveryAttempted || floorLift && !wait.floorLiftAttempted) {
+    if (options.claim) {
+      wait.recoveryAttempted ||= recovery;
+      wait.floorLiftAttempted ||= floorLift;
+    }
+    return false;
+  }
+  return true;
+}
+
 // src/tools/ctx-note/render.ts
 var GLANCE_TITLE_MAX = 80;
 var NUDGE_TITLE_MAX = 60;
@@ -20115,6 +21521,24 @@ function shouldSuppressHistorianAlert(sessionId) {
   lastHistorianAlertBySession.set(sessionId, Date.now());
   return false;
 }
+function isServingOrdinalDriftSignal(detail) {
+  if (!detail)
+    return false;
+  if (detail === "raw message count shrank")
+    return true;
+  return /(?:offset|protectedTailStart|eligibleEnd) ordinal \d+ id changed$/.test(detail);
+}
+function shouldRefuseStaleSnapshotForDrift(sessionId, detail) {
+  if (hasRawMessageProvider2(sessionId) || !openCodeDbExists())
+    return false;
+  return isServingOrdinalDriftSignal(detail);
+}
+function dropDriftedServingOrdinalRanks(sessionId, detail) {
+  if (hasRawMessageProvider2(sessionId) || !openCodeDbExists())
+    return;
+  withReadOnlySessionDb((reader) => dropRawSessionOrdinalCheckpoints2(reader, sessionId));
+  sessionLog2(sessionId, `historian: dropped drifted ordinal checkpoints after exact-read disagreement (${detail}); the next run rebuilds them from a full scan`);
+}
 function findDanglingPublicationBoundary(sessionId, compartments, messageExists = hasRawSessionMessageById2) {
   for (const compartment of compartments) {
     if (!messageExists(sessionId, compartment.startMessageId)) {
@@ -20282,7 +21706,16 @@ async function runCompartmentAgent(deps) {
       }
       return;
     }
-    const offset = priorCompartments.length > 0 ? priorCompartments[priorCompartments.length - 1].endMessage + 1 : 1;
+    let offset;
+    try {
+      offset = resolveHistorianChunkStart2(sessionId, priorCompartments[priorCompartments.length - 1] ?? null);
+    } catch (error) {
+      if (error instanceof RawOrdinalsNotReady2) {
+        deferUntilOrdinalsReady("chunk start unreadable");
+        return;
+      }
+      throw error;
+    }
     let boundarySnapshot = deps.boundarySnapshot ?? null;
     if (!boundarySnapshot) {
       telemetry.failureReason = "missing protected-tail boundary snapshot";
@@ -20292,17 +21725,34 @@ async function runCompartmentAgent(deps) {
     }
     let validation = { ok: true };
     if (boundarySnapshot.rawRangeFingerprint.length > 0) {
-      const checked = await validateBoundarySnapshotOffThread({
-        db,
-        snapshot: boundarySnapshot,
-        currentContextLimit: deps.currentContextLimit ?? boundarySnapshot.contextLimit
-      });
+      let checked;
+      try {
+        checked = await validateBoundarySnapshotOffThread({
+          db,
+          snapshot: boundarySnapshot,
+          currentContextLimit: deps.currentContextLimit ?? boundarySnapshot.contextLimit
+        });
+      } catch (error) {
+        if (error instanceof RawOrdinalsNotReady2) {
+          deferUntilOrdinalsReady("boundary validation unreadable");
+          return;
+        }
+        throw error;
+      }
       if (checked.kind === "not-ready") {
         deferUntilOrdinalsReady(`boundary validation ${checked.reason}`);
         return;
       }
       validation = checked.result;
     }
+    if (!validation.ok && validation.reason === "stale_snapshot" && shouldRefuseStaleSnapshotForDrift(sessionId, validation.detail)) {
+      dropDriftedServingOrdinalRanks(sessionId, validation.detail ?? validation.reason ?? "stale_snapshot");
+      sessionLog2(sessionId, `historian: refusing to publish over a stale protected-tail snapshot (was: ${validation.detail ?? "stale"}); ending the run without publishing`);
+      telemetry.status = "noop";
+      telemetry.failureReason = "stale_snapshot";
+      rollbackDrainReservation();
+      return;
+    }
     if (!validation.ok && validation.reason === "stale_snapshot") {
       const refreshed = deps.refreshBoundarySnapshot ? deps.refreshBoundarySnapshot(boundarySnapshot, validation) : resolveOpenCodeProtectedTailBoundary({
         db,
@@ -20389,6 +21839,14 @@ async function runCompartmentAgent(deps) {
       sessionLog2(sessionId, `historian prompt fit: sized to ${producerModel ?? "unknown"} (${describeHistorianPromptTrim(promptFit)}; requestedChunkTokens=${historianChunkTokens})`);
     }
     const perRunCap = selectPerRunCap(boundarySnapshot);
+    if (!deps.forceDrainQuota && shouldWaitForNewHistorianHistory(boundarySnapshot, {
+      emergency: getOverflowState(db, sessionId).needsEmergencyRecovery
+    })) {
+      telemetry.status = "noop";
+      telemetry.failureReason = "waiting for new history after no forward progress";
+      sessionLog2(sessionId, "historian no-op: waiting for new history after no forward progress");
+      return;
+    }
     const usable = Math.max(1, Math.round(boundarySnapshot.contextLimit * boundarySnapshot.executeThresholdPercentage / 100));
     const reserve = deps.forceDrainQuota ? { ok: true, reservation: null } : reserveProtectedTailDrainTokens({
       db,
@@ -20495,6 +21953,12 @@ ${chunkText}`,
     const maxExistingSequence = priorCompartments.reduce((max, c) => c.sequence > max ? c.sequence : max, -1);
     const sequenceOffset = priorCompartments.length === 0 ? 0 : maxExistingSequence + 1;
     retainDrainReservationForRetryThrottle = true;
+    if (!deps.forceDrainQuota) {
+      shouldWaitForNewHistorianHistory(boundarySnapshot, {
+        emergency: getOverflowState(db, sessionId).needsEmergencyRecovery,
+        claim: true
+      });
+    }
     const validatedPass = await runValidatedHistorianPass({
       client,
       hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
@@ -20546,7 +22010,11 @@ ${chunkText}`,
       sessionLog2(sessionId, `historian failure: source=no-progress reason="historian returned compartments that did not advance past raw message ${offset - 1}" newCompartmentCount=${newCompartments.length} lastNewEnd=${lastNewEnd} priorEnd=${offset - 1}`);
       sessionLog2(sessionId, "historian output discarded: reason=no_forward_progress");
       const failCount = incrementHistorianFailure(db, sessionId, `no forward progress beyond raw message ${offset - 1}`);
-      await notifyHistorianIssue(buildHistorianFailureNotice(failCount, `historian made no forward progress beyond raw message ${offset - 1}`));
+      try {
+        await notifyHistorianIssue(buildHistorianFailureNotice(failCount, `historian made no forward progress beyond raw message ${offset - 1}`));
+      } finally {
+        recordHistorianNoProgress(boundarySnapshot, inEmergency);
+      }
       return;
     }
     retainDrainReservationForRetryThrottle = false;
@@ -20658,6 +22126,7 @@ ${chunkText}`,
       db.exec("COMMIT");
       published = true;
       publishCommitted = true;
+      clearHistorianHistoryWait(sessionId);
       finishHistorianPublishStage(sessionId, "publish-txn", transactionStartedAt, "completed", `compartments=${persistedCompartments.length}`);
       logSlowWriteTransaction("historian-publish", lockAcquiredAt);
     } catch (error) {
@@ -21793,4 +23262,4 @@ async function executeContextRecomp(deps, options = {}) {
   return (await executeContextRecompWithResult(deps, options)).message;
 }
 
-export { denyTaskRoutingToCallerAgents, buildHiddenAgentRegistrations, buildZenReadAgentRegistrations, buildHiddenAgentConfig, getMagicContextBuiltinCommands, formatConfigParseStatusLine, claimConfigParseFailuresOnce, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, resolveLegacyConfigSources, migrateMagicContextConfigLocations, getProtectedTokensTierOverrides, loadPluginConfigDetailed, historianRunConfig, dreamerRunConfig, pluginConfigReader, currentPluginConfigReader, withLiveDreamerOutputCap, createDreamerOutputCapSampler, COMPARTMENT_AGENT_SYSTEM_PROMPT, HISTORIAN_EDITOR_SYSTEM_PROMPT, COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, clampProducerAtomChars, producerInputTokenLimit, historianProducerReserve, producerPromptFailureReason, DREAMER_AGENT, DREAMER_RETROSPECTIVE_AGENT, DREAMER_PRIMER_INVESTIGATOR_AGENT, DREAMER_MEMORY_MAPPER_AGENT, DREAMER_CLASSIFIER_AGENT, DREAMER_DOCS_AGENT, DREAMER_REVIEWER_AGENT, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLeaseBestEffort, isCompartmentLeaseHeld, queueM0Mutation, getMaxM0MutationId, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, getUncoveredCompartmentEndsThrough, providerResponseFailed, isSuccessfulProviderCompletion, rememberUnpublishedAutoSearchNoHint, getUnpublishedAutoSearchNoHint, forgetUnpublishedAutoSearchNoHint, registerAutoSearchWork, cancelAutoSearchWork, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, markSessionCleanupPending, retryPendingSessionCleanups, retryPendingRustSessionCleanupsForProject, clearSession, requestPendingMaterialization, pendingMaterializationOrigin, hasPendingMaterializationOrigin, clearPendingMaterialization, recordSystemPromptForRequest, recordHeldHeadForRequest, bindSystemPromptResponse, isHeldHeadForRequest, deferDeliveredSystemRefresh, retirePendingSystemPromptDelivery, lkgProviderInputTotal, beginV2LkgRequest, claimLkgRequestIdentity, currentLkgRequestIdentity, noteCapturedLkgRequest, noteLkgProviderResponse, measuredLkgPrefix, clearLkgMeasuredRequest, saveLkgSlotToDb, clearPersistedLkgSlotStrict, loadPersistedLkgSlot, drainStaleLkgSlots, createDbLkgPersistence, resolveLkgModelKeys, createLkgEntryProjector, captureLkgSlot, validateAnthropicReasoningRuns, validateLkgSeam, replayLkg, coldStartRawServedIndex, coldStartUncapturedReplay, noteUncertifiedNormalLkg, hasProcessLocalLkgProof, lkgDirtyRevision, rememberLkgDirtyRevision, readPersistedLkgUntaggedInputIds, persistLkgUntaggedInputIds, noteLkgRecoveryPrefix, readLkgRecoveryPrefix, noteLkgHealthyPrefix, lkgRecoveryReplayUnproven, lkgRecoveryEntryUnproven, registerLkgPersistence, beginLkgPass, visitMessageContentFields, contentSnapshotValue, messageContentFields, signatureForFields, exactReusablePrefix, incrementalLkgContentDigests, lkgSlotRejection, captureSlot, getInMemorySlot, getSlot, forgetInMemorySlot, dropSlot, noteEntry, getLkgSlotHeapStats, TOOL_SWEEP_SCOPED_MARKER, useScopedToolSweep, createPreAdoptionToolSweepResolver, copySessionStateForClone, queueMemoryMutation, getMaxMemoryMutationIdForProjects, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectUserProfileVersion, saveSourceContent, replaceSourceContent, getSourceContents, createChildSessionWithFence, HiddenCompletionRefusal, DreamerProviderOutputFailureError, withDreamerModelCooldown, providerOutputFailureFromInvalidManifest, HIDDEN_HISTORIAN_AGENT, HIDDEN_DREAMER_AGENT, HIDDEN_CURATE_AGENT, hiddenAgentFor, hiddenToolLoop, HIDDEN_RUN_DISPOSED_REASON, noteChildOfDisposedInstance, hiddenChildPermissions, registerHiddenChildAgents, hiddenToolCallRefusal, HiddenAgentStepLimit, HiddenChildHook, extractLatestAssistantText, hasLengthCappedOutput, parseProviderModel, modelBodyField, toModelEntry, ModelProducedNoOutputError, noteModelActivityMonitored, noteModelOutputReceived, isPromptTimeoutError, getPromptFailureDetail, raceWithSignal, promptSyncWithValidatedOutputRetry, normalizeSDKResponse, annotateSubagentInvocationError, failedInvocationStatus, sumTokensFromChildMessages, recordChildInvocation, recordPromptSessionError, createPromptAsyncTransport, CTX_NOTE_LIGHT_DESCRIPTION, ACTIVE_TOOL_IDS, systemPromptFingerprint, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, setKeepSubagents, teardownChildSession, getCompartmentEvents, runTokenLog, formatRunTokenLog, buildMagicContextSection, getMuralIdentity, getMural, modelKeyAcceptsImages, resolveMuralWire, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, getOpenCodeDbPath, compareOpenCodeMessagesByCanonicalOrder, prepareCompactionMarkerCandidates, removeMcOwnedCompactionMarkers, MARKER_SUMMARY_TEXT, markerUpdateDefinitelyDidNotCut, applyDeferredCompactionMarker, removeCompactionMarkerForSession, checkCompactionMarkerConsistency, extractM0Block, formatDate, TEMPORAL_MARKER_REPLAY_PATTERN, collectTemporalCandidates, injectTemporalMarkers, clearInjectionCache, getVisibleMemoryIds, selectHiddenMessagesAtCompactionSeam, prepareCompartmentInjection, renderCompartmentInjection, MaterializeContentionError, mustMaterialize, trimMemoriesToBudgetV2, renderMemoryBlockV2, materializeM0, hydrateCachedM0Mural, resetPrefixTrimFallbackState, findHostCompactionWindow, capturePrefixTrimSourceOrder, prepareCachedM0M1Replay, hasCompleteCachedM0M1, injectM0M1, resolveHiddenCompletionExecutor, createV1HiddenCompletionExecutor, readCoordinateGeneration, readCoordinateRebaseNotice, formatCoordinateRebaseNotice, rebaseSessionCoordinatesAsync, EMPTY_READ_REPLY, noteTouchedAt, renderGlance, renderNotesById, formatWriteReply, observeNoteNudgeServe, onNoteTrigger, peekNoteNudgeText, markNoteNudgeDelivered, clearNoteNudgeTriggerAndCooldown, resetNoteNudgeCooldownOnly, clearNoteNudgeTriggerOnly, omitIncompleteFileTokenTotals, describeBoundaryDiagnostics, RECOVERY_NO_HEAD_LIMIT, deriveProtectedTailTokenTarget, selectPerRunCap, resolveOpenCodeProtectedTailBoundary, resolveWrapupProtectedTailBoundary, getRawHistoryEligibility, hasRunnableCompartmentWindow, recordHighPressureNoEligibleHead, noteTransformPassForExactOrdinalReads, runCompartmentAgent, snapRangeToCompartments, getActiveCompartmentRun, markActiveCompartmentRunPublished, registerActiveCompartmentRun, startCompartmentAgent, executeContextRecomp };
+export { denyTaskRoutingToCallerAgents, buildHiddenAgentRegistrations, buildZenReadAgentRegistrations, buildHiddenAgentConfig, getMagicContextBuiltinCommands, formatConfigParseStatusLine, claimConfigParseFailuresOnce, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, resolveLegacyConfigSources, migrateMagicContextConfigLocations, getProtectedTokensTierOverrides, loadPluginConfigDetailed, historianRunConfig, dreamerRunConfig, pluginConfigReader, currentPluginConfigReader, withLiveDreamerOutputCap, createDreamerOutputCapSampler, advanceSessionActivity, observeSessionActivity, backfillSessionActivity, COMPARTMENT_AGENT_SYSTEM_PROMPT, HISTORIAN_EDITOR_SYSTEM_PROMPT, COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, clampProducerAtomChars, producerInputTokenLimit, historianProducerReserve, producerPromptFailureReason, DREAMER_AGENT, DREAMER_RETROSPECTIVE_AGENT, DREAMER_PRIMER_INVESTIGATOR_AGENT, DREAMER_MEMORY_MAPPER_AGENT, DREAMER_CLASSIFIER_AGENT, DREAMER_DOCS_AGENT, DREAMER_REVIEWER_AGENT, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLeaseBestEffort, isCompartmentLeaseHeld, queueM0Mutation, getMaxM0MutationId, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, getUncoveredCompartmentEndsThrough, providerResponseFailed, isSuccessfulProviderCompletion, LkgRecoveryFenceError, lkgServedArrayDigest, hasCleanLkgRecoveryFence, dirtyLkgRecoveryRevision, ownsLkgDirtyFence, invalidateCleanLkgRecoveryFence, prepareLkgCaptureFence, certifyCommittedLkgCapture, markLkgRecoveryDirty, rememberUnpublishedAutoSearchNoHint, getUnpublishedAutoSearchNoHint, forgetUnpublishedAutoSearchNoHint, registerAutoSearchWork, cancelAutoSearchWork, gaDatabasePath, RAW_MESSAGE_TYPES, V2StoreReaderPool, V2StoreReader, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, markSessionCleanupPending, retryPendingSessionCleanups, retryPendingRustSessionCleanupsForProject, clearSession, requestPendingMaterialization, pendingMaterializationOrigin, hasPendingMaterializationOrigin, clearPendingMaterialization, recordSystemPromptForRequest, recordHeldHeadForRequest, bindSystemPromptResponse, isHeldHeadForRequest, deferDeliveredSystemRefresh, retirePendingSystemPromptDelivery, lkgProviderInputTotal, beginV2LkgRequest, claimLkgRequestIdentity, currentLkgRequestIdentity, noteCapturedLkgRequest, noteLkgProviderResponse, measuredLkgPrefix, clearLkgMeasuredRequest, saveLkgSlotToDb, clearPersistedLkgSlotStrict, loadPersistedLkgSlot, drainStaleLkgSlots, createDbLkgPersistence, resolveLkgModelKeys, createLkgEntryProjector, captureLkgSlot, validateAnthropicReasoningRuns, validateLkgSeam, replayLkg, coldStartRawServedIndex, coldStartUncapturedReplay, noteUncertifiedNormalLkg, hasProcessLocalLkgProof, lkgDirtyRevision, rememberLkgDirtyRevision, readPersistedLkgUntaggedInputIds, persistLkgUntaggedInputIds, noteLkgRecoveryPrefix, readLkgRecoveryPrefix, noteLkgHealthyPrefix, lkgRecoveryReplayUnproven, lkgRecoveryEntryUnproven, registerLkgPersistence, beginLkgPass, visitMessageContentFields, contentSnapshotValue, messageContentFields, signatureForFields, exactReusablePrefix, incrementalLkgContentDigests, lkgSlotRejection, captureSlot, getInMemorySlot, getSlot, forgetInMemorySlot, dropSlot, noteEntry, getLkgSlotHeapStats, TOOL_SWEEP_SCOPED_MARKER, useScopedToolSweep, createPreAdoptionToolSweepResolver, copySessionStateForClone, queueMemoryMutation, getMaxMemoryMutationIdForProjects, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectUserProfileVersion, saveSourceContent, replaceSourceContent, getSourceContents, createChildSessionWithFence, HiddenCompletionRefusal, DreamerProviderOutputFailureError, withDreamerModelCooldown, providerOutputFailureFromInvalidManifest, HIDDEN_HISTORIAN_AGENT, HIDDEN_DREAMER_AGENT, HIDDEN_CURATE_AGENT, hiddenAgentFor, hiddenToolLoop, HIDDEN_RUN_DISPOSED_REASON, noteChildOfDisposedInstance, hiddenChildPermissions, registerHiddenChildAgents, hiddenToolCallRefusal, HiddenAgentStepLimit, HiddenChildHook, extractLatestAssistantText, hasLengthCappedOutput, parseProviderModel, modelBodyField, toModelEntry, ModelProducedNoOutputError, noteModelActivityMonitored, noteModelOutputReceived, isPromptTimeoutError, getPromptFailureDetail, raceWithSignal, promptSyncWithValidatedOutputRetry, normalizeSDKResponse, annotateSubagentInvocationError, failedInvocationStatus, sumTokensFromChildMessages, recordChildInvocation, recordPromptSessionError, createPromptAsyncTransport, CTX_NOTE_LIGHT_DESCRIPTION, ACTIVE_TOOL_IDS, systemPromptFingerprint, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, setKeepSubagents, teardownChildSession, getCompartmentEvents, runTokenLog, formatRunTokenLog, buildMagicContextSection, getMuralIdentity, getMural, modelKeyAcceptsImages, resolveMuralWire, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, getOpenCodeDbPath, compareOpenCodeMessagesByCanonicalOrder, prepareCompactionMarkerCandidates, removeMcOwnedCompactionMarkers, MARKER_SUMMARY_TEXT, markerUpdateDefinitelyDidNotCut, applyDeferredCompactionMarker, removeCompactionMarkerForSession, checkCompactionMarkerConsistency, extractM0Block, formatDate, TEMPORAL_MARKER_REPLAY_PATTERN, collectTemporalCandidates, injectTemporalMarkers, clearInjectionCache, getVisibleMemoryIds, selectHiddenMessagesAtCompactionSeam, prepareCompartmentInjection, renderCompartmentInjection, MaterializeContentionError, mustMaterialize, trimMemoriesToBudgetV2, renderMemoryBlockV2, materializeM0, hydrateCachedM0Mural, resetPrefixTrimFallbackState, findHostCompactionWindow, capturePrefixTrimSourceOrder, prepareCachedM0M1Replay, hasCompleteCachedM0M1, injectM0M1, resolveHiddenCompletionExecutor, createV1HiddenCompletionExecutor, readCoordinateGeneration, readCoordinateRebaseNotice, formatCoordinateRebaseNotice, rebaseSessionCoordinatesAsync, shouldWaitForNewHistorianHistory, EMPTY_READ_REPLY, noteTouchedAt, renderGlance, renderNotesById, formatWriteReply, observeNoteNudgeServe, onNoteTrigger, peekNoteNudgeText, markNoteNudgeDelivered, clearNoteNudgeTriggerAndCooldown, resetNoteNudgeCooldownOnly, clearNoteNudgeTriggerOnly, omitIncompleteFileTokenTotals, describeBoundaryDiagnostics, RECOVERY_NO_HEAD_LIMIT, deriveProtectedTailTokenTarget, selectPerRunCap, resolveOpenCodeProtectedTailBoundary, resolveWrapupProtectedTailBoundary, getRawHistoryEligibility, hasRunnableCompartmentWindow, recordHighPressureNoEligibleHead, noteTransformPassForExactOrdinalReads, runCompartmentAgent, snapRangeToCompartments, getActiveCompartmentRun, markActiveCompartmentRunPublished, registerActiveCompartmentRun, startCompartmentAgent, executeContextRecomp };