@cortexkit/pi-magic-context 0.49.26 → 0.49.28

package/dist/{index-zpmz6x24.js → index-bkcwcghx.js}

@@ -67,7 +67,7 @@ import {
   visitRawSessionMessages2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-rjnc6kkf.js";
+} from "./index-kagezf2h.js";
 import {
   isRecord,
   providerVisibleMessage,
@@ -81,34 +81,33 @@ import {
   getTagNumberByMessageId2,
   getTagsBySession2,
   getTagById2
-} from "./index-n8e5e9fp.js";
+} from "./index-0x1c054v.js";
 import {
   estimateTokens
 } from "./index-my0dn413.js";
 import {
   inRootAsyncContext2,
   Database2,
+  prepareCachedStatement2,
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2
 } from "./index-2qtx0q6h.js";
 import {
   stableStringify,
   closeQuietly,
-  getTableColumnNames
-} from "./index-w1avzkdt.js";
+  getTableColumnNames,
+  tagTombstoneOwnerRange,
+  tagTombstoneOwnerKey,
+  tagRevisionKey,
+  tagIdentityRevisionKey,
+  deleteTagIdentityRevisions
+} from "./index-g026ztby.js";
 import {
   piHarnessKindFromExecutable,
-  isPidAlive
-} from "./index-n4wyxcgr.js";
-import {
-  clearLkgFenceProcessState,
-  commitLkgWithRecoveryFence,
-  clearLkgRecoveryFence,
-  gaDatabasePath,
-  V2StoreReader,
-  deleteSessionScopedRows,
-  getLastIndexedOrdinal2
-} from "./index-87xm7z44.js";
+  isPidAlive,
+  readProcessStartTime,
+  getErrorMessage
+} from "./index-5d506f7y.js";
 import {
   BoundedSessionMap,
   resolveOpenCodeDbPath,
@@ -116,7 +115,7 @@ import {
 } from "./index-23t8ryqw.js";
 import {
   noteRawSessionSummaryRowWritten2
-} from "./index-z24d75tz.js";
+} from "./index-6981g1xv.js";
 import {
   SubcClient,
   connectionFileExists,
@@ -124,6 +123,12 @@ import {
   toSynapseLaneDescriptor,
   SynapseEmbeddingProvider
 } from "./index-gwxaz0z5.js";
+import {
+  deleteUnmappedMessageFtsRows2
+} from "./index-bvpar0bg.js";
+import {
+  deleteChunkEmbedBackoffForSession2
+} from "./index-kmk3xpf9.js";
 import {
   invalidateAutoEmbedSession,
   drainBackgroundBatches,
@@ -136,10 +141,10 @@ import {
   unregisterProjectEmbedding2,
   getProjectEmbeddingSnapshot2,
   embedTextForProject2
-} from "./index-z6k6jsmh.js";
+} from "./index-xa90f88m.js";
 import {
-  getErrorMessage
-} from "./index-r1hvaza0.js";
+  getLastIndexedOrdinal
+} from "./index-v0ht940m.js";
 import {
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY,
@@ -153,13 +158,14 @@ import {
   expandWorkspaceIdentitySetWithAliases,
   resolveStoredPathWorkspaceIdentity,
   storedPathBelongsToWorkspace
-} from "./index-0dr64gsy.js";
+} from "./index-0s14xaca.js";
 import {
+  sameProjectDirectory,
   directoryHasGitMetadata,
   resolveProjectIdentityForSession,
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity
-} from "./index-hxp6q5f8.js";
+} from "./index-48twbev2.js";
 import {
   getNoteByIdInScope,
   getNotes,
@@ -175,7 +181,7 @@ import {
   resolveMemoriesByIdsForSearch2,
   unifiedSearch2,
   formatSearchResults2
-} from "./index-zz7dnyh6.js";
+} from "./index-sdsnb5b6.js";
 import {
   computeCueContentHash,
   getMuralCueState,
@@ -206,7 +212,7 @@ import {
 } from "./index-6wdwv3a6.js";
 import {
   renderSearchArchive2
-} from "./index-kbswhkc8.js";
+} from "./index-vea2d9ka.js";
 import {
   computeNormalizedHash
 } from "./index-9x1f96r8.js";
@@ -215,7 +221,11 @@ import {
 } from "./index-hqw0rt9k.js";
 import {
   ensureStorageDirectorySync,
-  writeStorageFileAtomicSync
+  ensurePrivateStorageDirectorySync,
+  writeStorageFileSync,
+  writeStorageFileAtomicSync,
+  syncStorageDirectorySync,
+  writeStorageFileDurableAtomicSync
 } from "./index-81nthk8j.js";
 
 // ../plugin/src/config/agent-disable.ts
@@ -2778,6 +2788,389 @@ function substituteConfigVariables(input) {
 // ../plugin/src/features/magic-context/storage-meta-session.ts
 import { Buffer as Buffer2 } from "node:buffer";
 
+// ../plugin/src/hooks/magic-context/lkg-recovery-fence.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { lstatSync, readdirSync as readdirSync2, readFileSync as readFileSync7, rmdirSync, rmSync as rmSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname4, join as join5 } from "node:path";
+
+// ../plugin/src/shared/storage-file-mutex.ts
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { readdirSync, readFileSync as readFileSync6, rmSync as rmSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+var ticketChecksum = (name, ticket) => createHash("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 = join4(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 = join4(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 });
+  }
+}
+
+// ../plugin/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 {
+    lstatSync(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) => createHash2("sha256").update(value).digest("hex");
+function lkgRecoveryFencePath(sessionId) {
+  return join5(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 createHash2("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 = lstatSync(path);
+    const directory = lstatSync(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(join5(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 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 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 {
+      lstatSync(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 {}
+  }
+}
+
 // ../plugin/src/shared/auto-search-lifecycle.ts
 var pending = new Map;
 var unpublishedNoHints = new Map;
@@ -2829,6 +3222,598 @@ function cancelAutoSearchWork(sessionId) {
   }
 }
 
+// ../plugin/src/v2/store-reader.ts
+import { createHash as createHash3 } from "node:crypto";
+import { statSync as statSync3 } 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 = statSync3(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;
+  }
+}
+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 createHash3("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;
+    }
+  }
+}
+
 // ../plugin/src/features/magic-context/resolve-subagent-fallback.ts
 function resolveIsSubagentFromOpenCodeDb(sessionId) {
   try {
@@ -2856,6 +3841,225 @@ function resolveIsSubagentFromOpenCode2Db(sessionId) {
   }
 }
 
+// ../plugin/src/features/magic-context/session-activity.ts
+var PREFIX = "retrospective_activity:";
+var INTERVAL_MS = 15000;
+var pending2 = new WeakMap;
+function sessionActivityKey(sessionId) {
+  return `${PREFIX}${sessionId}`;
+}
+function deleteSessionActivity(db, sessionIds) {
+  if (sessionIds.length === 0)
+    return;
+  const sessions = pending2.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 readSessionActivity(db, sessionId) {
+  const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(sessionActivityKey(sessionId));
+  const time = Number(row?.value);
+  return row && Number.isFinite(time) ? time : undefined;
+}
+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 = pending2.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    pending2.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);
+}
+
+// ../plugin/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;
+}
+
 // ../plugin/src/features/magic-context/storage-meta-session.ts
 var SESSION_META_FALLBACK_SELECTS = {
   cache_ttl: "'5m' AS cache_ttl",
@@ -3390,8 +4594,8 @@ function isPartialCompartmentEnd(db, sessionId, messageId) {
   return Boolean(db.prepare("SELECT 1 FROM compartments WHERE session_id=? AND end_message_id=? AND end_block_index IS NOT NULL LIMIT 1").get(sessionId, messageId));
 }
 // ../plugin/src/features/magic-context/project-docs-hash.ts
-import { createHash } from "node:crypto";
-import { lstatSync, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { lstatSync as lstatSync2, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
 import path from "node:path";
 var PROJECT_DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 var PROJECT_DOCS_DELIMITER = `
@@ -3410,7 +4614,7 @@ function canonicalizeDocContent(raw) {
 }
 function fingerprintFile(filePath) {
   try {
-    const stat = lstatSync(filePath);
+    const stat = lstatSync2(filePath);
     const isReadableDoc = stat.isFile() && stat.size <= MAX_PROJECT_DOC_BYTES;
     return {
       exists: isReadableDoc,
@@ -3423,7 +4627,7 @@ function fingerprintFile(filePath) {
 }
 function readDirectoryMtimeMs(projectDirectory) {
   try {
-    return statSync3(projectDirectory).mtimeMs;
+    return statSync4(projectDirectory).mtimeMs;
   } catch {
     return 0;
   }
@@ -3458,7 +4662,7 @@ function readCanonicalPieces(projectDirectory, files) {
     }
     let safeToRead = false;
     try {
-      const st = lstatSync(filePath);
+      const st = lstatSync2(filePath);
       safeToRead = st.isFile() && st.size <= MAX_PROJECT_DOC_BYTES;
     } catch {
       safeToRead = false;
@@ -3466,7 +4670,7 @@ function readCanonicalPieces(projectDirectory, files) {
     if (!safeToRead) {
       continue;
     }
-    const canonicalContent = canonicalizeDocContent(readFileSync6(filePath, "utf8"));
+    const canonicalContent = canonicalizeDocContent(readFileSync8(filePath, "utf8"));
     hashPieces.push(`file:${filename}
 ${canonicalContent}`);
     renderedSections.push(`<file name="${escapeXmlAttr(filename)}">
@@ -3489,7 +4693,7 @@ function hashCanonicalPieces(hashPieces) {
   if (hashPieces.length === 0) {
     return "";
   }
-  return createHash("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
+  return createHash4("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
 }
 function readProjectDocsCanonical(projectDirectory) {
   canonicalReadCountForTests += 1;
@@ -3515,7 +4719,7 @@ function readProjectDocsCanonical(projectDirectory) {
   return { renderedBlock, canonicalHash };
 }
 // ../plugin/src/hooks/magic-context/lkg-slot.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // ../plugin/src/shared/provider-response-completion.ts
 function providerResponseFailed(input) {
@@ -3567,7 +4771,7 @@ function hasOnlySystemHashMaterialization(sessions, sessionId) {
 }
 
 // ../plugin/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);
@@ -3583,11 +4787,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) {
@@ -3595,7 +4799,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;
@@ -3618,7 +4822,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)
@@ -3626,7 +4830,7 @@ function bindSystemPromptResponse(sessionId, request, response) {
   saved.response = { id: response.responseId, createdAt: response.createdAt };
 }
 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;
@@ -3668,10 +4872,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);
 }
 
 // ../plugin/src/hooks/magic-context/lkg-measured-request.ts
@@ -3683,7 +4887,7 @@ function clearCapturedLkgMeasurement(sessionId) {
 }
 
 // ../plugin/src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function parseStringArray(value) {
   if (typeof value !== "string")
     return null;
@@ -3797,7 +5001,7 @@ function rememberFingerprint(db, sessionId, fingerprint) {
   saved.set(sessionId, fingerprint);
 }
 function slotFingerprint(slot) {
-  return createHash2("sha256").update(JSON.stringify([
+  return createHash5("sha256").update(JSON.stringify([
     slot.jsonPrefix,
     slot.inputIdSeq,
     slot.inputContentDigests,
@@ -4461,7 +5665,7 @@ var DIGEST_CHUNK_BYTES = 64 * 1024;
 var digestChunk;
 function lkgContentDigestFromFields(fields) {
   lkgDigestsComputed += 1;
-  const hash = createHash3("sha256");
+  const hash = createHash6("sha256");
   digestChunk ??= Buffer.allocUnsafe(DIGEST_CHUNK_BYTES);
   const chunk = digestChunk;
   let offset = 0;
@@ -4524,7 +5728,7 @@ function legacyLkgDigestFromFields(fields) {
     const value = typeof field === "symbol" ? field.description ?? "" : String(field);
     key += `${typeof field}:${value.length}:${value}\x00`;
   }
-  return createHash3("sha256").update(key).digest("base64url");
+  return createHash6("sha256").update(key).digest("base64url");
 }
 function legacyLkgContentDigest(message) {
   const fields = flattenContentFields(withoutEmptyUserDiffSummary(message));
@@ -5001,17 +6205,17 @@ function isReservedLedgerControlEntry(entry) {
 }
 
 // ../plugin/src/features/magic-context/pi-content-decisions.ts
-var PREFIX = "pi-content-replay-v1:";
+var PREFIX2 = "pi-content-replay-v1:";
 var PI_CONTENT_DECISION_LIMIT = 4096;
 var PI_IDENTITY_RECURRENCE_ALLOWANCE = 64;
 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 {}
@@ -6082,9 +7286,9 @@ function formatNoteNudge(args) {
 }
 
 // ../plugin/src/shared/prompt-surface-runtime.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, resolve as resolve2 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync9, statSync as statSync5 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
 
 // ../plugin/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".`;
@@ -6115,22 +7319,22 @@ function promptSurfaceHashMaterial(systemContent, preset = "full") {
 \x00magic-context-prompt-surface:${preset}`;
 }
 function systemPromptFingerprint(systemContent, preset = "full") {
-  return createHash4("md5").update(promptSurfaceHashMaterial(systemContent, preset)).digest("hex");
+  return createHash7("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;
@@ -6147,14 +7351,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 (!statSync4(path).isFile()) {
+      if (!statSync5(path).isFile()) {
         warnOnce(`guidance-not-file:${path}`, `prompt_surface.guidance_override_path (${path}) is not a file; using built-in guidance.`);
         return;
       }
-      content = readFileSync7(path, "utf8");
+      content = readFileSync9(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.`);
@@ -6229,7 +7433,7 @@ function createPromptSurfaceGuidanceEpochCache(runtime) {
 }
 
 // src/read-session-pi.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 var SYNTH_USER_ID_PREFIX = "synth-user-";
 function resolvePiStableId(msg, index, entryIds, entryIdByRef) {
   if (!msg || typeof msg !== "object")
@@ -6268,7 +7472,7 @@ function piContentFallbackIds(messages, resolveReal) {
       return;
     const m = message;
     const role = typeof m.role === "string" ? m.role : "unknown";
-    const digest = createHash5("sha256").update(stableStringify([
+    const digest = createHash8("sha256").update(stableStringify([
       typeof m.responseId === "string" ? m.responseId : null,
       typeof m.timestamp === "number" || typeof m.timestamp === "string" ? m.timestamp : null,
       role,
@@ -7219,7 +8423,7 @@ function compareMemorySelectionPriority(left, right) {
 }
 
 // ../plugin/src/features/magic-context/mural/render-trigger.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/mural/mural-selection.ts
 var DEFAULT_MURAL_MEMORY_BUDGET = 8000;
@@ -7908,7 +9112,7 @@ function ensureMuralRendered(db, projectIdentity, budgetTokens = DEFAULT_MURAL_M
     return { ...cached.result };
   }
   const plan = planMuralRender(entries);
-  const textHash = createHash6("sha256").update(plan.layout.text).digest("hex");
+  const textHash = createHash9("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,
@@ -7965,14 +9169,14 @@ function resolveMuralWire(db, projectIdentity, modelKey, enabled, budgetTokens =
 }
 
 // ../plugin/src/features/magic-context/compaction-marker.ts
-import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync6, statSync as statSync5 } from "node:fs";
+import { createHash as createHash10 } from "node:crypto";
+import { existsSync as existsSync6, statSync as statSync6 } 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${createHash7("sha256").update(seed).digest("hex")}`);
+  let value = BigInt(`0x${createHash10("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)];
@@ -8035,7 +9239,7 @@ function runMarkerWriteTransaction(db, site, operation) {
 function markerWalPages(db) {
   try {
     const row = db.prepare("PRAGMA page_size").get();
-    const bytes = statSync5(`${getOpenCodeDbPath()}-wal`).size;
+    const bytes = statSync6(`${getOpenCodeDbPath()}-wal`).size;
     return Math.max(0, Math.floor((bytes - 32) / (row.page_size + 24)));
   } catch {
     return null;
@@ -9164,7 +10368,7 @@ function takeCurateSafetyRefusalCount(sessionId) {
 }
 
 // ../plugin/src/features/magic-context/smart-notes/wake-plane.ts
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 var WAKE_PLANE_CAPABILITY = "wake.create";
 var WAKE_PLANE_STATUS_TTL_MS = 5 * 60 * 1000;
 var WAKE_PLANE_HANDSHAKE_TIMEOUT_MS = 2000;
@@ -9173,7 +10377,7 @@ var inFlightProbe = null;
 var catalogProbe = probeWakePlaneCatalog;
 var now = () => Date.now();
 function connectionFile() {
-  return join4(getDataDir(), "cortexkit", "run", "subc-connection.json");
+  return join6(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 async function probeWakePlaneCatalog() {
   const file = connectionFile();
@@ -9221,10 +10425,10 @@ async function wakePlaneStatus() {
 }
 
 // src/embedding-bootstrap.ts
-import { statSync as statSync6 } from "node:fs";
+import { statSync as statSync7 } from "node:fs";
 
 // ../plugin/src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -9272,7 +10476,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix(value, length = 16) {
-  return createHash8("sha256").update(value).digest("hex").slice(0, length);
+  return createHash11("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -9933,7 +11137,7 @@ function configCandidatePaths(directory, loadedPaths) {
 function configFingerprint(paths) {
   return paths.map((path) => {
     try {
-      const stat = statSync6(path);
+      const stat = statSync7(path);
       return `${path}:${stat.size}:${stat.mtimeMs}`;
     } catch {
       return `${path}:missing`;
@@ -10025,8 +11229,8 @@ function restoreOmpMentions(value) {
 }
 
 // src/pi-harness-kind.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname5, join as join5, parse as parse2, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, realpathSync as realpathSync2 } from "node:fs";
+import { dirname as dirname6, join as join7, parse as parse2, resolve as resolve4 } from "node:path";
 import { pathToFileURL } from "node:url";
 var OMP_UTILS_MODULE = "@oh-my-pi/pi-utils";
 var OMP_HOST_PACKAGE = "@oh-my-pi/pi-coding-agent";
@@ -10042,7 +11246,7 @@ function hostEntries() {
   for (const candidate of [process.argv[1], process.execPath]) {
     if (!candidate)
       continue;
-    const requestedPath = resolve3(candidate);
+    const requestedPath = resolve4(candidate);
     let resolvedPath;
     try {
       resolvedPath = realpathSync2(requestedPath);
@@ -10058,23 +11262,23 @@ function hostEntries() {
 }
 function readPackageJson(path) {
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync10(path, "utf8"));
   } catch {
     return;
   }
 }
 function nearestPackageName(entryPath) {
-  let directory = dirname5(entryPath);
+  let directory = dirname6(entryPath);
   const root = parse2(directory).root;
   while (true) {
-    const packagePath = join5(directory, "package.json");
+    const packagePath = join7(directory, "package.json");
     if (existsSync8(packagePath)) {
       const name = readPackageJson(packagePath)?.name;
       return typeof name === "string" ? name : undefined;
     }
     if (directory === root)
       return;
-    directory = dirname5(directory);
+    directory = dirname6(directory);
   }
 }
 function packageNameDetection(entries) {
@@ -10091,15 +11295,15 @@ function packageNameDetection(entries) {
 }
 function dependencyPackageRoot(entryPath, moduleName) {
   const moduleParts = moduleName.split("/");
-  let directory = dirname5(entryPath);
+  let directory = dirname6(entryPath);
   const root = parse2(directory).root;
   while (true) {
-    const packageRoot = join5(directory, "node_modules", ...moduleParts);
-    if (existsSync8(join5(packageRoot, "package.json")))
+    const packageRoot = join7(directory, "node_modules", ...moduleParts);
+    if (existsSync8(join7(packageRoot, "package.json")))
       return packageRoot;
     if (directory === root)
       return;
-    directory = dirname5(directory);
+    directory = dirname6(directory);
   }
 }
 function importTarget(exportsValue) {
@@ -10118,11 +11322,11 @@ function hostModuleImportUrl(entryPath) {
   const packageRoot = dependencyPackageRoot(entryPath, OMP_UTILS_MODULE);
   if (!packageRoot)
     return;
-  const packageJson = readPackageJson(join5(packageRoot, "package.json"));
+  const packageJson = readPackageJson(join7(packageRoot, "package.json"));
   const target = importTarget(packageJson?.exports) ?? (typeof packageJson?.module === "string" ? packageJson.module : typeof packageJson?.main === "string" ? packageJson.main : undefined);
   if (!target?.startsWith("./"))
     return;
-  return pathToFileURL(resolve3(packageRoot, target)).href;
+  return pathToFileURL(resolve4(packageRoot, target)).href;
 }
 async function appNameDetection(entries) {
   for (const entry of entries) {
@@ -10545,7 +11749,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // ../plugin/src/tools/ctx-expand/render.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -10769,7 +11973,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord3(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord3(part) && typeof part.text === "string" && createHash9("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord3(part) && typeof part.text === "string" && createHash12("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   return selected ? renderPartFull(selected) ?? "" : `Tag ${number}'s original text part is no longer in stored history.`;
 }
@@ -11862,7 +13066,7 @@ import { isAbsolute as isAbsolute5 } from "node:path";
 // ../retina-local-fs/src/path-fence.ts
 import { lstat, realpath } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute4, join as join6, relative, resolve as resolve4, sep } from "node:path";
+import { basename as basename4, dirname as dirname7, isAbsolute as isAbsolute4, join as join8, relative, resolve as resolve5, sep } from "node:path";
 
 // ../retina-local-fs/src/errors.ts
 class ProviderError extends Error {
@@ -11877,8 +13081,8 @@ class ProviderError extends Error {
 // ../retina-local-fs/src/path-fence.ts
 async function resolveAndFenceProviderPath(configuredPath, options) {
   const { home, dataDirectory, aliases } = await resolveFenceRoots(options);
-  const expanded = configuredPath.startsWith("~/") ? join6(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
-  const absolute = isAbsolute4(expanded) ? resolve4(expanded) : resolve4(options.cwd ?? process.cwd(), expanded);
+  const expanded = configuredPath.startsWith("~/") ? join8(home, configuredPath.slice(2)) : configuredPath === "~" ? home : configuredPath;
+  const absolute = isAbsolute4(expanded) ? resolve5(expanded) : resolve5(options.cwd ?? process.cwd(), expanded);
   const canonical = await canonicalPath(absolute, options.allowMissing);
   if (fenceCandidates(canonical, aliases).some((candidate) => isFencedPath(candidate, home, dataDirectory))) {
     throw new ProviderError("fenced_path", `Refusing fenced path: ${canonical}`);
@@ -11887,20 +13091,20 @@ async function resolveAndFenceProviderPath(configuredPath, options) {
 }
 var FENCED_CORTEXKIT_ROOTS = ["plexus", "claustrum", "staging", "run", "magic-context"];
 async function resolveFenceRoots(options) {
-  const configuredHomePath = resolve4(options.homeDirectory ?? process.env.HOME ?? homedir3());
+  const configuredHomePath = resolve5(options.homeDirectory ?? process.env.HOME ?? homedir3());
   let home;
   try {
     home = await realpath(configuredHomePath);
   } catch (error) {
     throw fsError(configuredHomePath, error);
   }
-  const configuredDataDirectory = resolve4(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join6(home, ".local", "share"));
+  const configuredDataDirectory = resolve5(options.dataDirectory ?? process.env.XDG_DATA_HOME ?? join8(home, ".local", "share"));
   const dataDirectory = await canonicalPath(configuredDataDirectory, true);
   const aliases = [];
-  const logicalCortexkit = join6(dataDirectory, "cortexkit");
+  const logicalCortexkit = join8(dataDirectory, "cortexkit");
   for (const logical of [
     logicalCortexkit,
-    ...FENCED_CORTEXKIT_ROOTS.map((root) => join6(logicalCortexkit, root))
+    ...FENCED_CORTEXKIT_ROOTS.map((root) => join8(logicalCortexkit, root))
   ]) {
     const canonical = await canonicalPath(logical, true);
     if (canonical !== logical)
@@ -11914,7 +13118,7 @@ function fenceCandidates(canonical, aliases) {
     const relativeToAlias = relative(alias.canonical, canonical);
     const inside = relativeToAlias === "" || relativeToAlias !== ".." && !relativeToAlias.startsWith(`..${sep}`) && !isAbsolute4(relativeToAlias);
     if (inside)
-      candidates.push(join6(alias.logical, relativeToAlias));
+      candidates.push(join8(alias.logical, relativeToAlias));
   }
   return candidates;
 }
@@ -11938,14 +13142,14 @@ async function canonicalPath(path, allowMissing) {
       }
       if (symbolicLink)
         throw fsError(path, error);
-      const parent = dirname6(candidate);
+      const parent = dirname7(candidate);
       if (parent === candidate) {
         throw fsError(path, error);
       }
-      suffix.unshift(basename3(candidate));
+      suffix.unshift(basename4(candidate));
       candidate = parent;
       try {
-        return join6(await realpath(candidate), ...suffix);
+        return join8(await realpath(candidate), ...suffix);
       } catch (parentError) {
         if (!isMissingError(parentError)) {
           throw fsError(path, parentError);
@@ -11954,13 +13158,13 @@ async function canonicalPath(path, allowMissing) {
     }
   }
 }
-function isFencedPath(canonicalPath, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join6(resolve4(homeDirectory), ".local", "share")) {
-  const cortexkitRoot = join6(resolve4(dataDirectory), "cortexkit");
+function isFencedPath(canonicalPath, homeDirectory, dataDirectory = process.env.XDG_DATA_HOME ?? join8(resolve5(homeDirectory), ".local", "share")) {
+  const cortexkitRoot = join8(resolve5(dataDirectory), "cortexkit");
   const relativeToCortexkit = relative(cortexkitRoot, canonicalPath);
   const insideCortexkit = relativeToCortexkit !== "" && relativeToCortexkit !== ".." && !relativeToCortexkit.startsWith(`..${sep}`) && !isAbsolute4(relativeToCortexkit);
   const parts = insideCortexkit ? relativeToCortexkit.split(sep) : [];
   const pathParts = canonicalPath.split(sep).filter(Boolean);
-  const name = basename3(canonicalPath);
+  const name = basename4(canonicalPath);
   const catalogDirectoryCarveIn = pathParts.includes("catalog");
   const moduleBinCarveIn = parts.length >= 2 && parts[1] === "bin";
   const catalogJsonCarveIn = name.endsWith(".json") && name.includes("catalog");
@@ -12422,7 +13626,7 @@ function err3(text) {
 }
 function captureAnchorOrdinal(db, sessionId) {
   try {
-    const ordinal = getLastIndexedOrdinal2(db, sessionId);
+    const ordinal = getLastIndexedOrdinal(db, sessionId);
     return ordinal > 0 ? ordinal : null;
   } catch {
     return null;
@@ -13649,4 +14853,4 @@ function registerMagicContextTools(pi, opts) {
   }
 }
 
-export { COMPACTION_ENABLED_PATH, isDreamerRunnable, isCompactionEnabled, formatConfigParseStatusLine, formatConfigParseNotice, claimConfigParseFailuresOnce, parseJsoncRecovering, detectConfigFile, OPENCODE_OUTPUT_CAP, MIN_PLAUSIBLE_CONTEXT_LIMIT, catalogOutputReserve, deriveWindowGeometry, hasTrustedAbsoluteWall, applyProvenInputFloor, formatWindowDerivationLine, formatWindowSource, isSaneLimit, resolveOutputReserve, getSdkWindowGeometry, getSdkContextLimit, getSdkOutputLimit, getSdkInputLimit, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, migrateMagicContextConfigLocations, getProtectedTokensTierOverrides, rememberUnpublishedAutoSearchNoHint, getUnpublishedAutoSearchNoHint, forgetUnpublishedAutoSearchNoHint, registerAutoSearchWork, cancelAutoSearchWork, readSessionMeta, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, retryPendingSessionCleanups, retryPendingRustSessionCleanupsForProject, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLease, releaseCompartmentLeaseBestEffort, isCompartmentLeaseHeld, isNoContentCompartment, HAS_COMPARTMENT_CONTENT_SQL, queueM0Mutation, getMaxM0MutationId, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, getCompartmentsByEndMessageId, appendCompartments, saveRecompStagingPass, getRecompStaging, clearRecompStaging, getRecompPartialRange, setRecompPartialRange, escapeXmlAttr, escapeXmlContent, getUncoveredCompartmentEndThrough, isPartialCompartmentEnd, readProjectDocsCanonical, providerResponseFailed, isSuccessfulProviderCompletion, requestPendingMaterialization, pendingMaterializationOrigin, hasPendingMaterializationOrigin, clearPendingMaterialization, recordSystemRefreshOwnership, recordSystemPromptForRequest, recordHeldHeadForRequest, bindSystemPromptResponse, acknowledgeSystemPromptDelivery, deferDeliveredSystemRefresh, clearSystemPromptDelivery, saveLkgSlotToDb, loadPersistedLkgSlot, drainStaleLkgSlots, createDbLkgPersistence, replayLkg, registerLkgPersistence, LKG_SNAPSHOT_ARRAY, LKG_SNAPSHOT_OBJECT, LKG_SNAPSHOT_KEY, LKG_SNAPSHOT_STRING, LKG_SNAPSHOT_NUMBER, LKG_SNAPSHOT_BOOLEAN, LKG_SNAPSHOT_NULL, LKG_SNAPSHOT_UNDEFINED, contentSnapshotValue, signatureForFields, lkgContentFields, lkgContentDigestFromFields, isLegacyLkgDigest, legacyLkgDigestFromFields, lkgFieldsMatchDigest, exactReusablePrefix, incrementalLkgContentDigests, lkgSlotRejection, captureSlot, getInMemorySlot, getSlot, dropSlot, TOOL_SWEEP_SCOPED_MARKER, encodePiContentDecision, decodePiContentDecision, getPiContentDecisions, freezePiContentDecision, getNativeReplayState, saveNativeToolInputs, addNativeReasoningIds, copySessionStateForClone, externalHistorianFailureReason, subprocessExitHistorianFailureReason, countHistorianRuns, recordHistorianRun, summarizeImportance, tallyFactsByCategory, queueMemoryMutation, getMemoryMutationsForRender, getMemoryMutationsForRenderByProjects, getMaxMemoryMutationId, getMaxMemoryMutationIdForProjects, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectUserProfileVersion, saveSourceContent, getSourceContents, recordSubagentInvocation, getLatestHistorianInvocationId, noteTouchedAt, noteNudgePickIndex, formatNoteNudge, systemPromptFingerprint, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, SYNTH_USER_ID_PREFIX, resolvePiStableId, resolvePiRealStableId, isPiContentFallbackId, isPiIndexFallbackId, piContentFallbackIds, readPiSessionSnapshot, readPiSessionMessages, readPiSessionMessagePage, findRestartModelSeedFromBranch, iterateEntriesToRawMessageRange, iterateAsyncEntriesToRawMessageRange, convertEntriesToRawMessages, convertPiAssistantEntryById, convertEntriesToRawMessagePage, countPiRawMessages, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, getTaskScheduleState, getFailingDreamTasks, getSkippedDreamTasks, getMostRecentTaskRunAt, pruneNonCanonicalTaskRows, deleteTaskScheduleRowsForProject, seedTaskScheduleState, writeTaskScheduleState, isRetrospectiveWindowProcessed, recordRetrospectiveWindowProcessed, curateCategoryForMemoryCategory, peekCurateCategoryScope, beginCurateCategoryRun, curateTaskStateAfterSuccess, MEMORY_MURAL_BLOCK, buildMagicContextSection, resolveMuralWire, updateCompactionMarkerAfterPublication, COMPARTMENT_RENDER_EPOCH, MEMORY_RENDER_FORMAT_EPOCH, encodeCachedM0UpgradeIdentity, decodeCachedM0UpgradeIdentity, withCachedM0MemoryIds, readCachedM0MemoryIds, renderBudgetIdentityChanged, renderedBudgetSnapshot, renderedBudgetShrinkReason, DEFAULT_HISTORY_BUDGET_TOKENS, renderCompartmentAtTier, renderDecayedCompartments, extractM0Block, TEMPORAL_MARKER_PATTERN, TEMPORAL_MARKER_REPLAY_PATTERN, temporalMarkerPrefix, renderUserProfileContent, clearInjectionCache, getVisibleMemoryIds, orderHistorianMemories, renderHistorianMemoryBlock, DEFAULT_MEMORY_BUDGET_TOKENS, DEFAULT_USER_PROFILE_BUDGET_TOKENS, trimMemoriesToBudgetV2, trimWorkspaceMemoriesToBudgetV2, trimUserMemoriesToBudget, renderMemoryBlockV2, stripMemoryMuralBlock, resetPrefixTrimFallbackState, isDirectiveShapedProjectRule, takeCurateSafetyRefusalCount, wakePlaneStatus, loadPiConfig, loadPiConfigDetailed, unregisterPiProjectEmbeddings, ensureProjectRegisteredFromPiDirectory, neutralizeOmpMentions, restoreOmpMentions, resolvePiHarnessDetection, resolvePiHarnessKind, resolvePiOrdinalAlignment, piRawOrdinalOffsetSource, resolvePiOrdinalAlignmentForContext, isPiOrdinalAlignmentUnanchored, clearPiOrdinalAlignmentSession, rememberTodowriteToolCallTodos, parseTodos, setTodoSnapshot, registerTodoOverlay, registerTodoStateLifecycle, syncCtxMemoryToolEnabled, registerMagicContextTools };
+export { COMPACTION_ENABLED_PATH, isDreamerRunnable, isCompactionEnabled, formatConfigParseStatusLine, formatConfigParseNotice, claimConfigParseFailuresOnce, parseJsoncRecovering, detectConfigFile, OPENCODE_OUTPUT_CAP, MIN_PLAUSIBLE_CONTEXT_LIMIT, catalogOutputReserve, deriveWindowGeometry, hasTrustedAbsoluteWall, applyProvenInputFloor, formatWindowDerivationLine, formatWindowSource, isSaneLimit, resolveOutputReserve, getSdkWindowGeometry, getSdkContextLimit, getSdkOutputLimit, getSdkInputLimit, cortexKitUserConfigBasePath, cortexKitProjectConfigBasePath, migrateMagicContextConfigLocations, getProtectedTokensTierOverrides, LkgRecoveryFenceError, clearLkgFenceProcessState, lkgFenceRequiresRebuild, lkgRecoveryFenceUnclean, ownsLkgDirtyFence, invalidateCleanLkgRecoveryFence, markLkgRecoveryDirty, rememberUnpublishedAutoSearchNoHint, getUnpublishedAutoSearchNoHint, forgetUnpublishedAutoSearchNoHint, registerAutoSearchWork, cancelAutoSearchWork, readSessionActivity, observeSessionActivity, backfillSessionActivity, readSessionMeta, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, retryPendingSessionCleanups, retryPendingRustSessionCleanupsForProject, COMPARTMENT_LEASE_RENEWAL_MS, acquireCompartmentLease, renewCompartmentLease, releaseCompartmentLease, releaseCompartmentLeaseBestEffort, isCompartmentLeaseHeld, isNoContentCompartment, HAS_COMPARTMENT_CONTENT_SQL, queueM0Mutation, getMaxM0MutationId, getCompartments, getLastCompartmentEndMessage, getLastCompartmentEndMessageId, getCompartmentsByEndMessageId, appendCompartments, saveRecompStagingPass, getRecompStaging, clearRecompStaging, getRecompPartialRange, setRecompPartialRange, escapeXmlAttr, escapeXmlContent, getUncoveredCompartmentEndThrough, isPartialCompartmentEnd, readProjectDocsCanonical, providerResponseFailed, isSuccessfulProviderCompletion, requestPendingMaterialization, pendingMaterializationOrigin, hasPendingMaterializationOrigin, clearPendingMaterialization, recordSystemRefreshOwnership, recordSystemPromptForRequest, recordHeldHeadForRequest, bindSystemPromptResponse, acknowledgeSystemPromptDelivery, deferDeliveredSystemRefresh, clearSystemPromptDelivery, saveLkgSlotToDb, loadPersistedLkgSlot, drainStaleLkgSlots, createDbLkgPersistence, replayLkg, registerLkgPersistence, LKG_SNAPSHOT_ARRAY, LKG_SNAPSHOT_OBJECT, LKG_SNAPSHOT_KEY, LKG_SNAPSHOT_STRING, LKG_SNAPSHOT_NUMBER, LKG_SNAPSHOT_BOOLEAN, LKG_SNAPSHOT_NULL, LKG_SNAPSHOT_UNDEFINED, contentSnapshotValue, signatureForFields, lkgContentFields, lkgContentDigestFromFields, isLegacyLkgDigest, legacyLkgDigestFromFields, lkgFieldsMatchDigest, exactReusablePrefix, incrementalLkgContentDigests, lkgSlotRejection, captureSlot, getInMemorySlot, getSlot, dropSlot, TOOL_SWEEP_SCOPED_MARKER, encodePiContentDecision, decodePiContentDecision, getPiContentDecisions, freezePiContentDecision, getNativeReplayState, saveNativeToolInputs, addNativeReasoningIds, copySessionStateForClone, externalHistorianFailureReason, subprocessExitHistorianFailureReason, countHistorianRuns, recordHistorianRun, summarizeImportance, tallyFactsByCategory, queueMemoryMutation, getMemoryMutationsForRender, getMemoryMutationsForRenderByProjects, getMaxMemoryMutationId, getMaxMemoryMutationIdForProjects, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, bumpProjectUserProfileVersion, saveSourceContent, getSourceContents, recordSubagentInvocation, getLatestHistorianInvocationId, noteTouchedAt, noteNudgePickIndex, formatNoteNudge, systemPromptFingerprint, createPromptSurfaceRuntime, createPromptSurfaceGuidanceEpochCache, SYNTH_USER_ID_PREFIX, resolvePiStableId, resolvePiRealStableId, isPiContentFallbackId, isPiIndexFallbackId, piContentFallbackIds, readPiSessionSnapshot, readPiSessionMessages, readPiSessionMessagePage, findRestartModelSeedFromBranch, iterateEntriesToRawMessageRange, iterateAsyncEntriesToRawMessageRange, convertEntriesToRawMessages, convertPiAssistantEntryById, convertEntriesToRawMessagePage, countPiRawMessages, USER_MEMORY_CANDIDATE_TTL_MS, insertUserMemoryCandidates, getUserMemoryCandidates, deleteUserMemoryCandidates, pruneExpiredUserMemoryCandidates, insertUserMemory, getActiveUserMemories, updateUserMemoryContent, dismissUserMemory, getTaskScheduleState, getFailingDreamTasks, getSkippedDreamTasks, getMostRecentTaskRunAt, pruneNonCanonicalTaskRows, deleteTaskScheduleRowsForProject, seedTaskScheduleState, writeTaskScheduleState, isRetrospectiveWindowProcessed, recordRetrospectiveWindowProcessed, curateCategoryForMemoryCategory, peekCurateCategoryScope, beginCurateCategoryRun, curateTaskStateAfterSuccess, MEMORY_MURAL_BLOCK, buildMagicContextSection, resolveMuralWire, updateCompactionMarkerAfterPublication, COMPARTMENT_RENDER_EPOCH, MEMORY_RENDER_FORMAT_EPOCH, encodeCachedM0UpgradeIdentity, decodeCachedM0UpgradeIdentity, withCachedM0MemoryIds, readCachedM0MemoryIds, renderBudgetIdentityChanged, renderedBudgetSnapshot, renderedBudgetShrinkReason, DEFAULT_HISTORY_BUDGET_TOKENS, renderCompartmentAtTier, renderDecayedCompartments, extractM0Block, TEMPORAL_MARKER_PATTERN, TEMPORAL_MARKER_REPLAY_PATTERN, temporalMarkerPrefix, renderUserProfileContent, clearInjectionCache, getVisibleMemoryIds, orderHistorianMemories, renderHistorianMemoryBlock, DEFAULT_MEMORY_BUDGET_TOKENS, DEFAULT_USER_PROFILE_BUDGET_TOKENS, trimMemoriesToBudgetV2, trimWorkspaceMemoriesToBudgetV2, trimUserMemoriesToBudget, renderMemoryBlockV2, stripMemoryMuralBlock, resetPrefixTrimFallbackState, isDirectiveShapedProjectRule, takeCurateSafetyRefusalCount, wakePlaneStatus, loadPiConfig, loadPiConfigDetailed, unregisterPiProjectEmbeddings, ensureProjectRegisteredFromPiDirectory, neutralizeOmpMentions, restoreOmpMentions, resolvePiHarnessDetection, resolvePiHarnessKind, resolvePiOrdinalAlignment, piRawOrdinalOffsetSource, resolvePiOrdinalAlignmentForContext, isPiOrdinalAlignmentUnanchored, clearPiOrdinalAlignmentSession, rememberTodowriteToolCallTodos, parseTodos, setTodoSnapshot, registerTodoOverlay, registerTodoStateLifecycle, syncCtxMemoryToolEnabled, registerMagicContextTools };