@cortexkit/pi-magic-context 0.49.0 → 0.49.1

package/dist/{index-r024r8da.js → index-4gfq5t09.js}

@@ -6,6 +6,21 @@ import {
   logSlowWriteTransaction
 } from "./index-0vrkp1jq.js";
 
+// ../plugin/src/shared/project-directory-key.ts
+import path from "node:path";
+function projectDirectoryKey(directory) {
+  const slashed = directory.replaceAll("\\", "/").replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
+  if (/^[a-z]:\//i.test(slashed) || slashed.startsWith("//")) {
+    return path.win32.normalize(slashed).replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
+  }
+  return path.resolve(directory);
+}
+function sameProjectDirectory(a, b) {
+  if (a.length === 0 || b.length === 0)
+    return false;
+  return projectDirectoryKey(a) === projectDirectoryKey(b);
+}
+
 // ../plugin/src/features/magic-context/message-fts-rowid-map.ts
 import { createHash } from "node:crypto";
 var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
@@ -168,4 +183,4 @@ function deleteUnmappedMessageFtsRows(db, sessionIds) {
          WHERE rowid > ? AND session_id IN (${placeholders})`).run(state.watermarkRowid, ...sessionIds);
 }
 
-export { recordMessageFtsRowid, recordIndexedMessageTime, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows };
+export { projectDirectoryKey, sameProjectDirectory, recordMessageFtsRowid, recordIndexedMessageTime, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows };

package/dist/{index-vf38qhee.js → index-81nthk8j.js}

@@ -4,6 +4,7 @@ import {
   chmodSync,
   closeSync,
   createWriteStream,
+  fsyncSync,
   lstatSync,
   mkdirSync,
   openSync,
@@ -32,6 +33,14 @@ function ensureStorageDirectorySync(directory, forcePrivate = false, recursive =
     ...privateMode ? { mode: 448 } : {}
   });
 }
+function ensurePrivateStorageDirectorySync(directory) {
+  ensureStorageDirectorySync(directory, true);
+  const stat = lstatSync(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error("Private storage directory is not a real directory");
+  if (process.platform !== "win32")
+    chmodSync(directory, 448);
+}
 function writeStorageFileSync(filePath, content, options = {}) {
   const { forcePrivate = false, ...writeOptions } = options;
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
@@ -51,6 +60,35 @@ function writeStorageFileAtomicSync(filePath, content, forcePrivate = false) {
     throw error;
   }
 }
+function syncStorageDirectorySync(directory) {
+  const fd = openSync(directory, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function writeStorageFileDurableAtomicSync(filePath, content, afterTempSync) {
+  const directory = dirname(filePath);
+  ensurePrivateStorageDirectorySync(directory);
+  const tempPath = `${filePath}.${process.pid}.${randomBytes(12).toString("hex")}.tmp`;
+  let fd;
+  try {
+    fd = openStorageFileSync(tempPath, "wx", true);
+    writeFileSync(fd, content, "utf8");
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    afterTempSync?.();
+    renameSync(tempPath, filePath);
+    syncStorageDirectorySync(directory);
+    syncStorageDirectorySync(dirname(directory));
+  } finally {
+    if (fd !== undefined)
+      closeSync(fd);
+    rmSync(tempPath, { force: true });
+  }
+}
 function copyStorageFileSync(sourcePath, destinationPath, forcePrivate = false) {
   ensureStorageDirectorySync(dirname(destinationPath), forcePrivate);
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
@@ -94,6 +132,11 @@ function copyStorageTreeSync(sourcePath, destinationPath, forcePrivate = false)
     copyStorageTreeSync(join(sourcePath, entry), join(destinationPath, entry), forcePrivate);
   }
 }
+function openStorageFileSync(filePath, flags, forcePrivate = false) {
+  ensureStorageDirectorySync(dirname(filePath), forcePrivate);
+  const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
+  return openSync(filePath, flags, privateMode ? 384 : 438);
+}
 async function writeStorageFileAsync(filePath, content, forcePrivate = false) {
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
   ensureStorageDirectorySync(dirname(filePath), privateMode);
@@ -147,4 +190,4 @@ function tightenStorageTreeSync(root) {
   return { tightened, failures };
 }
 
-export { setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions, ensureStorageDirectorySync, writeStorageFileSync, writeStorageFileAtomicSync, copyStorageFileSync, copyStorageTreeSync, writeStorageFileAsync, writeStorageFileHandleAsync, createStorageFileHandleAsync, tightenStorageTreeSync };
+export { setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions, ensureStorageDirectorySync, ensurePrivateStorageDirectorySync, writeStorageFileSync, writeStorageFileAtomicSync, syncStorageDirectorySync, writeStorageFileDurableAtomicSync, copyStorageFileSync, copyStorageTreeSync, writeStorageFileAsync, writeStorageFileHandleAsync, createStorageFileHandleAsync, tightenStorageTreeSync };

package/dist/{index-yzcjxnt2.js → index-b2anqqad.js}

@@ -1,6 +1,13 @@
 import {
   getHarness2
 } from "./index-0h2mkab2.js";
+import {
+  getMagicContextStorageDir
+} from "./index-x3dcnxh0.js";
+import {
+  isPidAlive,
+  readProcessStartTime
+} from "./index-0j0zqb4t.js";
 import {
   removeSystemReminders,
   hasMeaningfulUserText2,
@@ -15,10 +22,10 @@ import {
   recordIndexedMessageTime,
   messageFtsOrdinalRangeIsMapped,
   deleteUnmappedMessageFtsRows
-} from "./index-r024r8da.js";
+} from "./index-4gfq5t09.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./index-bejpsj10.js";
+} from "./index-27jh224p.js";
 import {
   closeQuietly,
   TAG_TOMBSTONE_OWNER_PREFIX,
@@ -30,10 +37,417 @@ import {
 } from "./index-mcgehvgw.js";
 import {
   cleanUserText2
-} from "./index-3rea6zd9.js";
+} from "./index-fqb1bddn.js";
 import {
   logSlowWriteTransaction
 } from "./index-0vrkp1jq.js";
+import {
+  ensurePrivateStorageDirectorySync,
+  writeStorageFileSync,
+  writeStorageFileAtomicSync,
+  syncStorageDirectorySync,
+  writeStorageFileDurableAtomicSync
+} from "./index-81nthk8j.js";
+
+// ../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 readFileSync2, rmSync as rmSync2 } from "node:fs";
+import { basename, dirname, join as join2 } from "node:path";
+
+// ../plugin/src/shared/bounded-session-map.ts
+class BoundedSessionMap {
+  maxEntries;
+  store = new Map;
+  constructor(maxEntries) {
+    if (!Number.isFinite(maxEntries) || maxEntries < 1) {
+      throw new Error(`BoundedSessionMap: maxEntries must be >= 1, got ${maxEntries}`);
+    }
+    this.maxEntries = maxEntries;
+  }
+  get(sessionId) {
+    const value = this.store.get(sessionId);
+    if (value === undefined)
+      return;
+    this.store.delete(sessionId);
+    this.store.set(sessionId, value);
+    return value;
+  }
+  peek(sessionId) {
+    return this.store.get(sessionId);
+  }
+  has(sessionId) {
+    return this.store.has(sessionId);
+  }
+  set(sessionId, value) {
+    if (this.store.has(sessionId)) {
+      this.store.delete(sessionId);
+    } else if (this.store.size >= this.maxEntries) {
+      const oldest = this.store.keys().next().value;
+      if (oldest !== undefined)
+        this.store.delete(oldest);
+    }
+    this.store.set(sessionId, value);
+  }
+  delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+}
+
+// ../plugin/src/shared/storage-file-mutex.ts
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { readdirSync, readFileSync, rmSync } from "node:fs";
+import { join } 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 = readFileSync(`/proc/${pid}/stat`, "utf8");
+      const ticks = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/)[19];
+      if (!ticks || !/^\d+$/.test(ticks))
+        return null;
+      return `${readFileSync("/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 = join(directory, name);
+  const birth = processBirth(process.pid);
+  const ticket = { choosing: true, number: 0, birth, checksum: "" };
+  const encodedTicket = () => JSON.stringify({ ...ticket, checksum: ticketChecksum(name, ticket) });
+  writeStorageFileSync(ownPath, encodedTicket(), { flag: "wx", forcePrivate: true });
+  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 = join(directory, other);
+      let value = null;
+      try {
+        const parsed = JSON.parse(readFileSync(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) {
+        rmSync(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 {
+    rmSync(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 join2(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(dirname(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(readFileSync2(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(dirname(path))) {
+      if (name.startsWith(`${basename(path)}.`) && name.endsWith(".tmp"))
+        rmSync2(join2(dirname(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?.();
+  return locked(sessionId, () => {
+    const result = remove?.();
+    if (shouldClear && !shouldClear(result))
+      return result;
+    rmSync2(lkgRecoveryFencePath(sessionId), { force: true });
+    syncStorageDirectorySync(dirname(lkgRecoveryFencePath(sessionId)));
+    clearLkgFenceProcessState(sessionId);
+    return result;
+  });
+}
 
 // ../plugin/src/features/magic-context/session-activity.ts
 var PREFIX = "retrospective_activity:";
@@ -232,6 +646,8 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
       retire.run(tagIdentityRevisionKey(id), tagRevisionKey(id), ...harnessTables.map(() => id), ...tagTombstoneOwnerRange(id));
     }
   }
+  for (const sessionId of deletableSessionIds)
+    clearLkgRecoveryFence(sessionId);
   return deletableSessionIds.length;
 }
 
@@ -259,7 +675,7 @@ function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
 }
 
 // ../plugin/src/features/magic-context/message-index.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 var MESSAGE_HISTORY_ORPHAN_SWEEP_BATCH_SIZE = 200;
 var MESSAGE_HISTORY_ORPHAN_SAFETY_AGE_MS = 24 * 60 * 60 * 1000;
 var MESSAGE_HISTORY_ORPHAN_SWEEP_COOLDOWN_MS = 10 * 60 * 1000;
@@ -445,7 +861,7 @@ function toMessageIndexSource(message) {
     role: message.role,
     createdAt: message.createdAt,
     sourceVersion: normalizeSourceVersion(message.version),
-    contentHash: createHash("sha256").update(content).digest("hex"),
+    contentHash: createHash3("sha256").update(content).digest("hex"),
     content
   };
 }
@@ -784,4 +1200,4 @@ function sweepOrphanedOpenCodeMessageIndexes(db, openReadableOpenCodeDb, options
   return withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(() => sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCodeDb, options)));
 }
 
-export { readSessionActivity, observeSessionActivity, backfillSessionActivity, deleteSessionScopedRows, clearCompressionDepth, clearCompressionDepthRange, MESSAGE_INDEX_MAX_FTS_BYTES, messageIndexSkipKey, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getIndexedMessageCorpusSize, markMessageIndexDirty, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, getIndexableContent, indexSingleMessage, indexMessagesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes };
+export { BoundedSessionMap, LkgRecoveryFenceError, clearLkgFenceProcessState, lkgFenceRequiresRebuild, lkgRecoveryFenceUnclean, ownsLkgDirtyFence, invalidateCleanLkgRecoveryFence, markLkgRecoveryDirty, commitLkgWithRecoveryFence, clearLkgRecoveryFence, readSessionActivity, observeSessionActivity, backfillSessionActivity, deleteSessionScopedRows, clearCompressionDepth, clearCompressionDepthRange, MESSAGE_INDEX_MAX_FTS_BYTES, messageIndexSkipKey, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getIndexedMessageCorpusSize, markMessageIndexDirty, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, getIndexableContent, indexSingleMessage, indexMessagesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes };