@cortexkit/opencode-magic-context 0.48.0 → 0.49.1

package/dist/{index-14cjxt20.js → index-sfhndpcb.js}

@@ -1,6 +1,11 @@
 import {
+  TAG_TOMBSTONE_OWNER_PREFIX,
+  tagTombstoneOwnerRange,
+  tagTombstoneOwnerKey,
+  tagRevisionKey,
+  tagIdentityRevisionKey,
   deleteTagIdentityRevisions
-} from "./index-db7zwa3v.js";
+} from "./index-1bt88epp.js";
 import {
   getHarness2
 } from "./index-pavzsdc6.js";
@@ -8,29 +13,88 @@ import {
   removeSystemReminders,
   hasMeaningfulUserText2,
   extractTexts2
-} from "./index-1qb0z7wa.js";
+} from "./index-qx53vezw.js";
+import {
+  getMagicContextStorageDir
+} from "./index-0sahzkwr.js";
 import {
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2
 } from "./index-kb9nn0a0.js";
 import {
   cleanUserText2
-} from "./index-bdckkfw6.js";
+} from "./index-sv0bb7vg.js";
 import {
   recordMessageFtsRowid,
   recordIndexedMessageTime,
   messageFtsOrdinalRangeIsMapped,
   deleteUnmappedMessageFtsRows
-} from "./index-fbv1dn35.js";
+} from "./index-7w18gg78.js";
+import {
+  isPidAlive,
+  readProcessStartTime
+} from "./index-6m7rdv7y.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./index-pg50n748.js";
+} from "./index-p1hnwfd8.js";
+import {
+  ensurePrivateStorageDirectorySync,
+  writeStorageFileSync,
+  writeStorageFileAtomicSync,
+  syncStorageDirectorySync,
+  writeStorageFileDurableAtomicSync
+} from "./index-fvnzcnww.js";
 import {
   closeQuietly
 } from "./index-8ajstryz.js";
 import {
   logSlowWriteTransaction
-} from "./index-2y0s2hep.js";
+} from "./index-4mjhqadz.js";
+
+// 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;
+  }
+}
 
 // src/features/magic-context/session-activity.ts
 var PREFIX = "retrospective_activity:";
@@ -134,7 +198,403 @@ function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
 }
 
 // src/features/magic-context/message-index.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
+
+// 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";
+
+// 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 });
+  }
+}
+
+// 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");
+var lkgServedArrayDigest = hash;
+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 dirtyLkgRecoveryRevision(sessionId, _slot) {
+  if (!durableFencesSupported())
+    return;
+  const record = known(sessionId).record;
+  return record?.state === "dirty" ? record.revision : undefined;
+}
+function ownsLkgDirtyFence(sessionId, revision) {
+  if (!durableFencesSupported())
+    return revision === "process-local";
+  const record = known(sessionId).record;
+  return revision !== undefined && record?.state === "dirty" && record.revision === revision;
+}
+function invalidateCleanLkgRecoveryFence(sessionId, load, ownRevision) {
+  if (!durableFencesSupported())
+    return "process-local";
+  const prior = known(sessionId);
+  if (prior.state === "dirty")
+    return prior.record?.revision === ownRevision ? ownRevision : undefined;
+  return locked(sessionId, () => {
+    const slot = load() ?? {
+      jsonPrefix: "",
+      inputIdSeq: [],
+      inputContentDigests: [],
+      lastInputMessageId: "",
+      modelKey: null,
+      providerKey: null,
+      capturedAt: 0
+    };
+    const record = read(sessionId);
+    if (record?.state !== "dirty") {
+      const revision = randomUUID2();
+      publish(sessionId, slot, "dirty", revision);
+      return revision;
+    }
+    return record?.state === "dirty" && record.revision === ownRevision ? ownRevision : undefined;
+  });
+}
+function prepareLkgCaptureFence(args) {
+  if (!durableFencesSupported())
+    return "process-local";
+  return locked(args.sessionId, () => {
+    const before = read(args.sessionId);
+    const owns = before?.state === "dirty" && before.revision === args.ownDirtyRevision;
+    const unchangedBytes = before?.state === "clean" && before.servedDigest === hash(args.slot.jsonPrefix);
+    if (!args.rebuild && before && !owns && !unchangedBytes && before.state !== "clean")
+      throw new LkgRecoveryFenceError(`A concurrent recovery requires a declared prefix rebuild (state=${before?.state}, owned=${owns}, previous=${!!args.previousSlot}, bytes=${unchangedBytes})`);
+    const revision = randomUUID2();
+    if (before)
+      publishRecord({ ...before, state: "dirty", revision });
+    else
+      publish(args.sessionId, args.previousSlot ?? args.slot, "dirty", revision);
+    return revision;
+  });
+}
+function certifyCommittedLkgCapture(args) {
+  if (!durableFencesSupported())
+    return false;
+  const state = known(args.sessionId);
+  if (state.state !== "dirty" || state.record?.revision !== args.revision)
+    return false;
+  return locked(args.sessionId, () => {
+    const before = read(args.sessionId);
+    if (before?.state !== "dirty" || before.revision !== args.revision)
+      return false;
+    const saved = args.load();
+    if (!saved || representationKey(saved) !== representationKey(args.slot) || hash(saved.jsonPrefix) !== args.latestServedDigest)
+      return false;
+    publish(args.sessionId, saved, "clean", args.revision);
+    return true;
+  });
+}
+function markLkgRecoveryDirty(args) {
+  if (!durableFencesSupported()) {
+    if (!args.processLocalProof)
+      throw new LkgRecoveryFenceError("Restart replay requires a healthy rebuild on Windows");
+    return "process-local";
+  }
+  const state = known(args.sessionId);
+  if (state.state === "dirty" && args.processLocalProof && state.record && state.record.revision === args.ownDirtyRevision)
+    return state.record.revision;
+  if (state.state === "invalid")
+    throw new LkgRecoveryFenceError("No clean durable recovery certificate");
+  return locked(args.sessionId, () => {
+    const slot = args.slot;
+    const before = read(args.sessionId);
+    if (before?.state === "dirty") {
+      if (!args.processLocalProof || before.revision !== args.ownDirtyRevision)
+        throw new LkgRecoveryFenceError(`Recovery superseded this process's last-good request (local=${args.processLocalProof}, owned=${before.revision === args.ownDirtyRevision})`);
+      return before.revision;
+    }
+    if (before && before.state !== "clean")
+      throw new LkgRecoveryFenceError("No clean durable recovery certificate");
+    const revision = randomUUID2();
+    publish(args.sessionId, slot, "dirty", revision);
+    return revision;
+  });
+}
+function commitLkgWithRecoveryFence(args) {
+  if (!durableFencesSupported())
+    return args.commit();
+  const state = known(args.sessionId);
+  if (state.state === "clean" && !args.requiredRevision && !args.retainDirtyRevision) {
+    const committed = args.commit();
+    if (committed) {
+      observer?.("committed");
+      remember(args.sessionId, { state: "clean", record: null });
+    }
+    return committed;
+  }
+  if (state.state === "invalid" && !args.rebuild)
+    throw new LkgRecoveryFenceError("Unproven prior request requires a prefix rebuild");
+  return locked(args.sessionId, () => {
+    const before = read(args.sessionId);
+    if (args.requiredRevision && before?.revision !== args.requiredRevision)
+      throw new LkgRecoveryFenceError("A later publisher superseded the rollback snapshot");
+    const ownsDirty = before?.state === "dirty" && (before.revision === args.retainDirtyRevision || before.revision === args.ownDirtyRevision);
+    if (before?.state === "dirty" && !ownsDirty && !args.rebuild)
+      throw new LkgRecoveryFenceError("A concurrent recovery requires a declared prefix rebuild");
+    if (before?.state !== "dirty" && state.state === "invalid")
+      publish(args.sessionId, args.load() ?? args.slot, "dirty", randomUUID2());
+    if (!args.commit())
+      return false;
+    observer?.("committed");
+    const saved = args.load();
+    if (!saved || representationKey(saved) !== representationKey(args.slot))
+      throw new LkgRecoveryFenceError("Last-good commit did not match its certificate");
+    if (args.retainDirtyRevision || args.cleanDigest !== undefined && hash(saved.jsonPrefix) !== args.cleanDigest)
+      return true;
+    const dirty = read(args.sessionId);
+    if (dirty?.state === "dirty")
+      publish(args.sessionId, saved, "clean", dirty.revision);
+    else
+      remember(args.sessionId, { state: "clean", record: null });
+    return true;
+  });
+}
+function clearLkgRecoveryFence(sessionId, remove, shouldClear) {
+  if (!durableFencesSupported())
+    return remove?.();
+  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;
+  });
+}
 
 // src/features/magic-context/storage-session-tables.ts
 var SESSION_SCOPED_TABLES = [
@@ -199,6 +659,17 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
   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 = db.prepare(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 = db.prepare("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 = db.prepare(`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)
     deleteChunkEmbedBackoffForSession(db, sessionId);
   for (const definition of SESSION_SCOPED_TABLES) {
@@ -225,6 +696,22 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
       statement.run(...deletableSessionIds);
   }
   deleteSessionActivity(db, deletableSessionIds);
+  if (!options.preserveTagRevisionTombstones) {
+    const retireOwner = db.prepare(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 = db.prepare(`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));
+    }
+  }
+  for (const sessionId of deletableSessionIds)
+    clearLkgRecoveryFence(sessionId);
   return deletableSessionIds.length;
 }
 
@@ -457,7 +944,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
   };
 }
@@ -710,12 +1197,19 @@ function persistMessageHistoryOrphanSweepState(db, cursor, lastSweptAt, harness)
              last_swept_at = excluded.last_swept_at`).run(harness, cursor, lastSweptAt);
 }
 function getOpenCodeSessionScopedCandidateSourceSql(harness) {
-  return SESSION_SCOPED_TABLES.filter((definition) => definition.harnessScoped === true).map((definition) => {
+  const sources = SESSION_SCOPED_TABLES.filter((definition) => definition.harnessScoped === true).map((definition) => {
     const predicates = ["session_id IS NOT NULL", `harness = '${harness}'`];
     if (definition.extraPredicate)
       predicates.push(definition.extraPredicate);
     return `SELECT session_id FROM ${definition.table} WHERE ${predicates.join(" AND ")}`;
-  }).join(`
+  });
+  const jsonId = `SUBSTR(key, ${TAG_TOMBSTONE_OWNER_PREFIX.length + 1}, LENGTH(key) - ${TAG_TOMBSTONE_OWNER_PREFIX.length + harness.length + 1})`;
+  sources.push(`SELECT CASE WHEN json_valid(${jsonId}) THEN
+        CASE WHEN json_type(${jsonId}) = 'text' THEN json_extract(${jsonId}, '$') END END AS session_id
+        FROM schema_migrations_meta WHERE value = '${harness}'
+        AND key >= '${TAG_TOMBSTONE_OWNER_PREFIX}' AND key < '${TAG_TOMBSTONE_OWNER_PREFIX.slice(0, -1)};'
+        AND SUBSTR(key, -${harness.length + 1}) = ':${harness}'`);
+  return sources.join(`
 UNION
 `);
 }
@@ -816,4 +1310,4 @@ function sweepOrphanedOpenCodeMessageIndexes(db, openReadableOpenCodeDb, options
   return withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(() => sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCodeDb, options)));
 }
 
-export { advanceSessionActivity, observeSessionActivity, backfillSessionActivity, clearCompressionDepth, clearCompressionDepthRange, deleteSessionScopedRows, MESSAGE_INDEX_MAX_FTS_BYTES, messageIndexSkipKey, toMessageIndexSource, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getIndexedMessageCorpusSize, markMessageIndexDirty, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, deleteIndexedMessage, clearIndexedMessagesInTransaction, clearIndexedMessages, getIndexableContent, indexSingleMessage, indexMessagesAfterOrdinal, indexSourcesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes };
+export { BoundedSessionMap, advanceSessionActivity, observeSessionActivity, backfillSessionActivity, clearCompressionDepth, clearCompressionDepthRange, LkgRecoveryFenceError, clearLkgFenceProcessState, lkgServedArrayDigest, hasCleanLkgRecoveryFence, lkgFenceRequiresRebuild, lkgRecoveryFenceUnclean, dirtyLkgRecoveryRevision, ownsLkgDirtyFence, invalidateCleanLkgRecoveryFence, prepareLkgCaptureFence, certifyCommittedLkgCapture, markLkgRecoveryDirty, commitLkgWithRecoveryFence, clearLkgRecoveryFence, deleteSessionScopedRows, MESSAGE_INDEX_MAX_FTS_BYTES, messageIndexSkipKey, toMessageIndexSource, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getIndexedMessageCorpusSize, markMessageIndexDirty, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, deleteIndexedMessage, clearIndexedMessagesInTransaction, clearIndexedMessages, getIndexableContent, indexSingleMessage, indexMessagesAfterOrdinal, indexSourcesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes };