@cortexkit/opencode-magic-context 0.49.15 → 0.49.17

package/dist/{index-thvnpfsv.js → index-cwzfcbtq.js}

@@ -9,34 +9,46 @@ import {
 import {
   getHarness2
 } from "./index-pavzsdc6.js";
+import {
+  getMagicContextStorageDir
+} from "./index-g2q4htwp.js";
+import {
+  isPidAlive,
+  readProcessStartTime
+} from "./index-nj7yykkx.js";
 import {
   removeSystemReminders,
+  removeNestedBlocks,
   hasMeaningfulUserText2,
   extractTexts2
-} from "./index-hqkczed7.js";
-import {
-  getMagicContextStorageDir
-} from "./index-g2q4htwp.js";
+} from "./index-c5pytzne.js";
 import {
+  Database2,
+  getSqliteDatabasePath2,
+  prepareCachedStatement2,
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2
-} from "./index-wafzvyhg.js";
+} from "./index-beht37jy.js";
 import {
-  cleanUserText2
-} from "./index-944w16m0.js";
+  resolveOpenCodeDbPath,
+  assertOpenCodeStoreGeneration
+} from "./index-58e3y90n.js";
 import {
-  recordMessageFtsRowid,
-  recordIndexedMessageTime,
-  messageFtsOrdinalRangeIsMapped,
-  deleteUnmappedMessageFtsRows
-} from "./index-dyvbsvga.js";
+  cleanUserText2
+} from "./index-p7m7j0cp.js";
 import {
-  isPidAlive,
-  readProcessStartTime
-} from "./index-nj7yykkx.js";
+  recordMessageFtsRowid2,
+  recordIndexedMessageTime2,
+  messageFtsOrdinalRangeIsMapped2,
+  getMessageFtsRowidMapBackfillProgress2,
+  deleteUnmappedMessageFtsRows2
+} from "./index-a6mc0v4d.js";
 import {
   deleteChunkEmbedBackoffForSession
-} from "./index-3kx0kg0f.js";
+} from "./index-b5vqckbw.js";
+import {
+  sameProjectDirectory
+} from "./index-knvkbfvh.js";
 import {
   closeQuietly
 } from "./index-8ajstryz.js";
@@ -198,11 +210,11 @@ function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
 }
 
 // src/features/magic-context/message-index.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } 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 { lstatSync, readdirSync as readdirSync2, readFileSync as readFileSync2, rmdirSync, rmSync as rmSync2 } from "node:fs";
 import { basename, dirname, join as join2 } from "node:path";
 
 // src/shared/storage-file-mutex.ts
@@ -247,7 +259,16 @@ function withStorageFileMutex(directory, work, timeoutMs = 1000) {
   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 });
+  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 = [];
@@ -585,15 +606,767 @@ function commitLkgWithRecoveryFence(args) {
 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)));
+  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;
+      rmSync2(lkgRecoveryFencePath(sessionId), { force: true });
+      syncStorageDirectorySync(dirname(lkgRecoveryFencePath(sessionId)));
+      clearLkgFenceProcessState(sessionId);
+      return result;
+    });
+  } finally {
+    try {
+      rmdirSync(`${path}.locks`);
+    } catch {}
+  }
+}
+
+// src/shared/search-text.ts
+function removeTaskNotifications(text) {
+  return removeNestedBlocks(text, ["task", "task_cohort"]);
+}
+function cleanSearchText(text) {
+  return removeNestedBlocks(text, ["system-reminder", "task", "task_cohort"]).replace(/\s+/g, " ").trim();
+}
+var QUERY_STOP_WORDS = new Set("a an and are as at be been by can could did do does for from how i in is it me my of on or our please should that the their them there these they this to us was we were what when where which who why will with would you your".split(" "));
+function terms(text) {
+  return [
+    ...new Set((text.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []).filter((term) => !QUERY_STOP_WORDS.has(term)))
+  ];
+}
+function keywordRelevance(query, content) {
+  const needles = terms(query);
+  if (needles.length === 0)
+    return 0;
+  const words = new Set(terms(cleanSearchText(content)));
+  return 0.8 * needles.filter((term) => words.has(term)).length / needles.length;
+}
+function matchedSearchSnippet(content, query, cap = 220) {
+  const text = cleanSearchText(content);
+  const needles = new Set(terms(query));
+  const matches = [...text.matchAll(/[\p{L}\p{N}_]+/gu)].filter((match) => needles.has(match[0].toLowerCase()));
+  if (matches.length === 0)
+    return "";
+  let bestStart = matches[0].index;
+  let bestCoverage = -1;
+  for (const match of matches) {
+    const start = Math.max(0, match.index - Math.floor(cap / 5));
+    const coverage = keywordRelevance(query, text.slice(start, start + cap));
+    if (coverage > bestCoverage) {
+      bestStart = start;
+      bestCoverage = coverage;
+    }
+  }
+  if (bestStart > 0) {
+    const boundary = text.indexOf(" ", bestStart);
+    if (boundary >= 0 && boundary < matches[matches.length - 1].index)
+      bestStart = boundary + 1;
+  }
+  const passage = text.slice(bestStart, bestStart + cap).trim();
+  return `${bestStart > 0 ? "…" : ""}${passage}${bestStart + cap < text.length ? "…" : ""}`;
+}
+
+// src/v2/store-reader.ts
+import { createHash as createHash3 } from "node:crypto";
+import { statSync } from "node:fs";
+import { hostname } from "node:os";
+import { resolve } 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 = statSync(path);
+  const acquiredIdentity = identity || `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+  const db = new Database2(path, { readonly: true, fileMustExist: true });
+  try {
+    assertOpenCodeStoreGeneration(db, "v2", path);
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+  const counters = debugCounters();
+  counters.openReaders += 1;
+  counters.readersOpened += 1;
+  counters.maxOpenReaders = Math.max(counters.maxOpenReaders, counters.openReaders);
+  return { db, statements: new Map, identity: acquiredIdentity, leases: 0, retired: false };
+}
+function closeConnection(connection) {
+  connection.statements.clear();
+  try {
+    connection.db.close();
+  } finally {
+    const counters = debugCounters();
+    counters.openReaders = Math.max(0, counters.openReaders - 1);
+    counters.readersClosed += 1;
+  }
+}
+
+class V2StoreReaderPool {
+  capacity;
+  connections = new Map;
+  closed = false;
+  closing = false;
+  holds = 0;
+  idleWaiters = new Set;
+  constructor(capacity = 4) {
+    this.capacity = capacity;
+    if (!Number.isSafeInteger(capacity) || capacity < 1)
+      throw new Error("Invalid reader capacity");
+  }
+  open(path) {
+    return new V2StoreReader(path, this);
+  }
+  acquire(path) {
+    if (this.closed)
+      throw new Error("Store reader pool is closed");
+    const key = resolve(path);
+    const stat = statSync(key);
+    const identity = `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+    let connection = this.connections.get(key);
+    if (connection && connection.identity !== identity) {
+      this.connections.delete(key);
+      this.retire(connection);
+      connection = undefined;
+    }
+    if (!connection)
+      connection = connect(key, identity);
+    connection.leases++;
+    this.connections.delete(key);
+    this.connections.set(key, connection);
+    while (this.connections.size > this.capacity) {
+      const oldest = this.connections.entries().next().value;
+      if (!oldest)
+        break;
+      this.connections.delete(oldest[0]);
+      this.retire(oldest[1]);
+    }
+    return connection;
+  }
+  release(connection) {
+    connection.leases--;
+    if (connection.retired && connection.leases === 0)
+      closeConnection(connection);
+  }
+  retire(connection) {
+    connection.retired = true;
+    if (connection.leases === 0)
+      closeConnection(connection);
+  }
+  hold() {
+    if (this.closed || this.closing)
+      throw new Error("Store reader pool is closed");
+    this.holds++;
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      this.holds--;
+      if (this.holds === 0 && this.closing)
+        this.finishClose();
+    };
+  }
+  isClosed() {
+    return this.closed;
+  }
+  holdCount() {
+    return this.holds;
+  }
+  close() {
+    if (this.closed || this.closing)
+      return;
+    this.closing = true;
+    if (this.holds === 0)
+      this.finishClose();
+  }
+  async closeWhenIdle(timeoutMs) {
+    this.close();
+    if (this.closed)
+      return true;
+    let timer;
+    let waiter;
+    try {
+      await new Promise((resolve) => {
+        waiter = resolve;
+        this.idleWaiters.add(resolve);
+        timer = setTimeout(resolve, Math.max(0, timeoutMs));
+      });
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      if (waiter)
+        this.idleWaiters.delete(waiter);
+    }
+    return this.closed;
+  }
+  finishClose() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    for (const connection of this.connections.values())
+      this.retire(connection);
+    this.connections.clear();
+    for (const resolve of this.idleWaiters)
+      resolve();
+    this.idleWaiters.clear();
+  }
+}
+
+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(), resolve(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;
+    });
+  }
+  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;
+  }
+  sessionIds() {
+    return this.prepare("SELECT id FROM session_v2").all().map((row) => row.id);
+  }
+  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(`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 (${batch.map(() => "?").join(",")})`).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);
+    });
+  }
+  sequenceForId(sessionID, id) {
+    if (!id)
+      return;
+    const row = this.prepare("SELECT seq FROM session_message WHERE session_id = ? AND id = ? LIMIT 1").get(sessionID, id);
+    return typeof row?.seq === "number" ? row.seq : undefined;
+  }
+  syntheticMessageIDs(sessionID) {
+    const rows = this.prepare("SELECT id FROM session_message WHERE session_id = ? AND type = 'synthetic'").all(sessionID);
+    return new Set(rows.map((row) => row.id));
+  }
+  forkOrigin(sessionID) {
+    const columns = new Set(this.prepare("PRAGMA table_info(session_v2)").all().map((column) => column.name));
+    if (!columns.has("fork_session_id") || !columns.has("fork_boundary"))
+      return null;
+    const row = this.prepare("SELECT fork_session_id, fork_boundary FROM session_v2 WHERE id = ?").get(sessionID);
+    if (!row?.fork_session_id || !row.fork_boundary)
+      return null;
+    try {
+      const boundary = JSON.parse(row.fork_boundary);
+      if (boundary.type !== "before" && boundary.type !== "through" || typeof boundary.messageID !== "string" || boundary.messageID.length === 0)
+        return null;
+      return {
+        parentSessionID: row.fork_session_id,
+        boundary: { type: boundary.type, messageID: boundary.messageID }
+      };
+    } catch {
+      return null;
+    }
+  }
+  sessionExists(sessionID) {
+    return this.prepare("SELECT 1 FROM session_v2 WHERE id = ?").get(sessionID) != null;
+  }
+  rowStampsThrough(sessionID, throughSeq) {
+    return this.prepare(`SELECT id, type, seq, time_created FROM session_message
+                 WHERE session_id = ? AND seq <= ? ORDER BY seq ASC`).all(sessionID, throughSeq);
+  }
+  latestSequenceForIds(sessionID, ids) {
+    let latest = -1;
+    for (let offset = 0;offset < ids.length; offset += 500) {
+      const chunk = ids.slice(offset, offset + 500);
+      const row = this.prepare(`SELECT MAX(seq) AS seq FROM session_message
+                     WHERE session_id = ? AND id IN (${chunk.map(() => "?").join(", ")})`).get(sessionID, ...chunk);
+      if (typeof row?.seq === "number")
+        latest = Math.max(latest, row.seq);
+    }
+    return latest;
+  }
+  compactionByStatus(sessionID, status) {
+    const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                WHERE session_id = ? AND type = 'compaction'
+                  AND json_extract(data, '$.status') = ?
+                ORDER BY seq DESC LIMIT 1`).get(sessionID, status);
+    return row ? decode(row) : undefined;
+  }
+  latestCompaction(sessionID) {
+    return trackDecodeOperation("latestCompaction", () => this.compactionByStatus(sessionID, "completed"));
+  }
+  latestRunningCompaction(sessionID) {
+    return trackDecodeOperation("latestRunningCompaction", () => this.compactionByStatus(sessionID, "running"));
+  }
+  idleRows(sessionID, after = -1) {
+    return trackDecodeOperation("idleRows", () => this.all(sessionID, after, "idle"));
+  }
+  earliestSequence(sessionID) {
+    const row = this.prepare("SELECT MIN(seq) AS seq FROM session_message WHERE session_id = ?").get(sessionID);
+    return typeof row?.seq === "number" ? row.seq : undefined;
+  }
+  latestSequence(sessionID) {
+    const row = this.prepare("SELECT MAX(seq) AS seq FROM session_message WHERE session_id = ?").get(sessionID);
+    return typeof row?.seq === "number" ? row.seq : -1;
+  }
+  assistantSince(sessionID, afterSeq) {
+    return trackDecodeOperation("assistantSince", () => {
+      const rows = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                    WHERE session_id = ? AND type = 'assistant' AND seq > ?
+                    ORDER BY seq ASC`).all(sessionID, afterSeq);
+      return rows.map((row) => decode(row));
+    });
+  }
+  latestAssistant(sessionID) {
+    return trackDecodeOperation("latestAssistant", () => {
+      const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                    WHERE session_id = ? AND type = 'assistant'
+                    ORDER BY seq DESC LIMIT 1`).get(sessionID);
+      return row ? decode(row) : undefined;
+    });
+  }
+  latestIdle(sessionID) {
+    return trackDecodeOperation("latestIdle", () => {
+      const row = this.prepare(`SELECT id, session_id, type, seq, time_created, data FROM session_message
+                    WHERE session_id = ? AND type = 'idle'
+                    ORDER BY seq DESC LIMIT 1`).get(sessionID);
+      return row ? decode(row) : undefined;
+    });
+  }
+  window(sessionID) {
+    return trackDecodeOperation("window", () => this.db.transaction(() => {
+      const cut = this.latestCompaction(sessionID);
+      return this.all(sessionID, cut ? cut.seq - 1 : -1);
+    }).deferred());
+  }
+  history(sessionID) {
+    return trackDecodeOperation("history", () => this.all(sessionID, -1));
+  }
+  all(sessionID, after, type, through) {
+    const rows = [];
+    for (;; ) {
+      const page = this.page(sessionID, { after, through, type });
+      rows.push(...page.rows);
+      if (page.rows.length < 100 || page.cursor === undefined)
+        return rows;
+      after = page.cursor;
+    }
+  }
 }
 
 // src/features/magic-context/storage-session-tables.ts
@@ -642,6 +1415,22 @@ var SESSION_SCOPED_TABLES = [
   { 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;
@@ -649,7 +1438,7 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
   if (options.rustModuleCleanupAcknowledged !== true) {
     const placeholders = sessionIds.map(() => "?").join(", ");
     const harnessPredicate = harness === undefined ? "" : " AND harness = ?";
-    const protectedRows = db.prepare(`SELECT session_id
+    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`]);
@@ -661,11 +1450,11 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
   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 (?, ?)");
+    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 = db.prepare(`INSERT INTO schema_migrations_meta (key, value)
+    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));
@@ -674,13 +1463,13 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
     deleteChunkEmbedBackoffForSession(db, sessionId);
   for (const definition of SESSION_SCOPED_TABLES) {
     if (definition.table === "message_history_fts") {
-      db.prepare(`DELETE FROM 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);
-      deleteUnmappedMessageFtsRows(db, deletableSessionIds);
+      deleteUnmappedMessageFtsRows2(db, deletableSessionIds);
       continue;
     }
     const predicates = [`session_id IN (${placeholders})`];
@@ -689,7 +1478,7 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
     const bindHarness = harness !== undefined && definition.harnessScoped === true;
     if (bindHarness)
       predicates.push("harness = ?");
-    const statement = db.prepare(`DELETE FROM ${definition.table} WHERE ${predicates.join(" AND ")}`);
+    const statement = cleanupStatement(db, `DELETE FROM ${definition.table} WHERE ${predicates.join(" AND ")}`);
     if (bindHarness)
       statement.run(...deletableSessionIds, harness);
     else
@@ -697,9 +1486,9 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
   }
   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 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 = db.prepare(`DELETE FROM schema_migrations_meta WHERE key IN (?, ?)
+    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) {
@@ -710,10 +1499,59 @@ function deleteSessionScopedRows(db, sessionIds, harness, options = {}) {
       retire.run(tagIdentityRevisionKey(id), tagRevisionKey(id), ...harnessTables.map(() => id), ...tagTombstoneOwnerRange(id));
     }
   }
-  for (const sessionId of deletableSessionIds)
-    clearLkgRecoveryFence(sessionId);
+  if (!options.deferRecoveryFenceCleanup)
+    for (const sessionId of deletableSessionIds)
+      clearLkgRecoveryFence(sessionId);
   return deletableSessionIds.length;
 }
+var SESSION_CLEANUP_SLICE_ROWS = 64;
+function deleteSessionScopedRowsSlice(db, sessionId, harness) {
+  if (cleanupStatement(db, "SELECT 1 FROM pending_session_cleanup WHERE session_id = ? AND harness = ?").get(sessionId, `${harness}:rust`))
+    return { complete: true, deleted: 0 };
+  cleanupStatement(db, "INSERT OR IGNORE INTO schema_migrations_meta(key,value) VALUES (?,?)").run(tagTombstoneOwnerKey(sessionId, harness), harness);
+  let remaining = SESSION_CLEANUP_SLICE_ROWS;
+  const started = performance.now();
+  remaining -= deleteChunkEmbedBackoffForSession(db, sessionId, remaining);
+  if (remaining <= 0)
+    return { complete: false, deleted: 0 };
+  for (const definition of SESSION_SCOPED_TABLES) {
+    if (definition.table === "message_history_fts") {
+      const rows = cleanupStatement(db, "SELECT fts_rowid AS id FROM message_fts_rowid_map WHERE session_id = ? LIMIT ?").all(sessionId, remaining);
+      const removeFts = cleanupStatement(db, "DELETE FROM message_history_fts WHERE rowid = ?");
+      const removeMap = cleanupStatement(db, "DELETE FROM message_fts_rowid_map WHERE session_id = ? AND fts_rowid = ?");
+      for (const row of rows) {
+        removeFts.run(row.id);
+        removeMap.run(sessionId, row.id);
+      }
+      remaining -= rows.length;
+      if (remaining > 0 && !getMessageFtsRowidMapBackfillProgress2(db).completed)
+        remaining -= cleanupStatement(db, `DELETE FROM message_history_fts WHERE rowid IN (
+                    SELECT rowid FROM message_history_fts WHERE session_id = ? LIMIT ?
+                )`).run(sessionId, remaining).changes;
+    } else {
+      const predicates = ["session_id = ?"];
+      if (definition.extraPredicate)
+        predicates.push(definition.extraPredicate);
+      if (definition.harnessScoped)
+        predicates.push("harness = ?");
+      const args = [sessionId, ...definition.harnessScoped ? [harness] : [], remaining];
+      const withoutRowid = definition.table === "temporal_decisions" || definition.table === "session_replay_decisions";
+      const key = withoutRowid ? "message_id" : "rowid";
+      remaining -= cleanupStatement(db, `DELETE FROM ${definition.table}
+                WHERE ${withoutRowid ? "session_id = ? AND " : ""}${key} IN (
+                    SELECT ${key} FROM ${definition.table} WHERE ${predicates.join(" AND ")} LIMIT ?
+                )`).run(...withoutRowid ? [sessionId] : [], ...args).changes;
+    }
+    if (remaining <= 0 || performance.now() - started >= 10)
+      return { complete: false, deleted: 0 };
+  }
+  return {
+    complete: true,
+    deleted: deleteSessionScopedRows(db, [sessionId], harness, {
+      deferRecoveryFenceCleanup: true
+    })
+  };
+}
 
 // src/features/magic-context/message-index.ts
 var MESSAGE_HISTORY_ORPHAN_SWEEP_BATCH_SIZE = 200;
@@ -927,7 +1765,7 @@ function getDeleteMessageFtsMapStatement(db) {
 }
 function insertMessageFtsRow(db, sessionId, messageOrdinal, messageId, role, content, messageTimeMs) {
   const result = getInsertMessageStatement(db).run(sessionId, messageOrdinal, messageId, role, content);
-  recordMessageFtsRowid(db, sessionId, messageOrdinal, result.lastInsertRowid, messageTimeMs ?? null);
+  recordMessageFtsRowid2(db, sessionId, messageOrdinal, result.lastInsertRowid, messageTimeMs ?? null);
 }
 function normalizeSourceVersion(version) {
   if (typeof version === "number")
@@ -944,7 +1782,7 @@ function toMessageIndexSource2(message) {
     role: message.role,
     createdAt: message.createdAt,
     sourceVersion: normalizeSourceVersion(message.version),
-    contentHash: createHash3("sha256").update(content).digest("hex"),
+    contentHash: createHash4("sha256").update(content).digest("hex"),
     content
   };
 }
@@ -1027,7 +1865,7 @@ function deleteIndexedMessage2(db, sessionId, messageId) {
 function clearIndexedMessagesInTransaction2(db, sessionId) {
   deleteMessageIndexSkips(db, sessionId);
   getDeleteFtsStatement(db).run(sessionId);
-  deleteUnmappedMessageFtsRows(db, [sessionId]);
+  deleteUnmappedMessageFtsRows2(db, [sessionId]);
   getDeleteFtsMapStatement(db).run(sessionId);
   getDeleteMessageSourceStatement(db).run(sessionId);
   getDeleteIndexStatement(db).run(sessionId);
@@ -1046,10 +1884,10 @@ function getIndexableContent2(role, parts) {
     if (!hasMeaningfulUserText2(parts)) {
       return "";
     }
-    return extractTexts2(parts).map(cleanUserText2).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
+    return extractTexts2(parts).map(removeTaskNotifications).map(cleanUserText2).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
   }
   if (role === "assistant") {
-    return extractTexts2(parts).map(removeSystemReminders).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
+    return extractTexts2(parts).map(removeTaskNotifications).map(removeSystemReminders).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
   }
   return "";
 }
@@ -1058,10 +1896,10 @@ function indexSingleMessageInTransaction(db, sessionId, message, now, dirtyFloor
   const dirtyFloor = getDirtyIndexFloor(db, sessionId);
   if (message.ordinal <= currentWatermark) {
     if (isIndexSourceCurrent(db, sessionId, source)) {
-      recordIndexedMessageTime(db, sessionId, message.ordinal, message.createdAt);
+      recordIndexedMessageTime2(db, sessionId, message.ordinal, message.createdAt);
       return false;
     }
-    if (!messageFtsOrdinalRangeIsMapped(db, sessionId, message.ordinal, message.ordinal)) {
+    if (!messageFtsOrdinalRangeIsMapped2(db, sessionId, message.ordinal, message.ordinal)) {
       return false;
     }
     getDeleteMessageFtsStatement(db).run(sessionId, message.id);
@@ -1091,7 +1929,7 @@ function indexSingleMessage2(db, sessionId, message, shouldCommit = () => true,
   const source = preparedSource ?? getMessageSourceSnapshot(message);
   const currentWatermark = getLastIndexedOrdinal2(db, sessionId);
   if (message.ordinal <= currentWatermark && isIndexSourceCurrent(db, sessionId, source)) {
-    recordIndexedMessageTime(db, sessionId, message.ordinal, message.createdAt);
+    recordIndexedMessageTime2(db, sessionId, message.ordinal, message.createdAt);
     return false;
   }
   const dirtyFloorBeforeAttempt = getDirtyIndexFloor(db, sessionId);
@@ -1132,7 +1970,7 @@ function indexItemsAfterOrdinal(db, sessionId, items, finalWatermark, toSource)
     const currentWatermark = getLastIndexedOrdinal2(db, sessionId);
     const dirtyFloor = getDirtyIndexFloor(db, sessionId);
     const effectiveWatermark = dirtyFloor === null ? currentWatermark : Math.min(currentWatermark, Math.max(0, dirtyFloor - 1));
-    if (dirtyFloor !== null && dirtyFloor <= currentWatermark && !messageFtsOrdinalRangeIsMapped(db, sessionId, dirtyFloor, Math.min(currentWatermark, finalWatermark))) {
+    if (dirtyFloor !== null && dirtyFloor <= currentWatermark && !messageFtsOrdinalRangeIsMapped2(db, sessionId, dirtyFloor, Math.min(currentWatermark, finalWatermark))) {
       db.exec("COMMIT");
       committed = true;
       logSlowWriteTransaction("message_index_reconcile", transactionStartedAt);
@@ -1184,7 +2022,7 @@ function indexItemsAfterOrdinal(db, sessionId, items, finalWatermark, toSource)
   return inserted;
 }
 function harnessSupportsOpenCodeOrphanSweep(harness) {
-  return harness === "opencode";
+  return harness === "opencode" || harness === "opencode2";
 }
 function getMessageHistoryOrphanSweepState(db, harness) {
   return db.prepare("SELECT cursor_session_id, last_swept_at FROM message_history_orphan_sweep WHERE harness = ?").get(harness) ?? {};
@@ -1213,7 +2051,7 @@ function getOpenCodeSessionScopedCandidateSourceSql(harness) {
 UNION
 `);
 }
-function sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCodeDb, options = {}) {
+function* sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCodeDb, options = {}) {
   const now = options.now ?? Date.now();
   const batchSize = Math.max(1, Math.floor(options.batchSize ?? MESSAGE_HISTORY_ORPHAN_SWEEP_BATCH_SIZE));
   const safetyAgeMs = Math.max(0, options.safetyAgeMs ?? MESSAGE_HISTORY_ORPHAN_SAFETY_AGE_MS);
@@ -1227,15 +2065,6 @@ function sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCod
   }
   if (!harnessSupportsOpenCodeOrphanSweep(harness)) {
     persistMessageHistoryOrphanSweepState(db, cursor, now + unavailableReprobeMs - cooldownMs, harness);
-    if (harness === "opencode2") {
-      return {
-        status: "unavailable",
-        scanned: 0,
-        deleted: 0,
-        cursor,
-        reason: "OpenCode 2 keeps its sessions in session_v2, which this sweep does not read"
-      };
-    }
     return { status: "unavailable", scanned: 0, deleted: 0, cursor };
   }
   let openCodeDb = null;
@@ -1248,7 +2077,27 @@ function sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCod
     persistMessageHistoryOrphanSweepState(db, cursor, now + unavailableReprobeMs - cooldownMs, harness);
     return { status: "source_unavailable", scanned: 0, deleted: 0, cursor };
   }
+  let v2Reader;
   try {
+    let sessionExists;
+    if (harness === "opencode2") {
+      try {
+        const path = getSqliteDatabasePath2(openCodeDb);
+        if (!path)
+          throw new Error("OpenCode 2 source has no durable path");
+        v2Reader = new V2StoreReader(path);
+        const liveIds = new Set(v2Reader.sessionIds());
+        if (liveIds.size === 0)
+          throw new Error("OpenCode 2 source has no sessions");
+        sessionExists = (id) => liveIds.has(id);
+      } catch {
+        persistMessageHistoryOrphanSweepState(db, cursor, now + unavailableReprobeMs - cooldownMs, harness);
+        return { status: "source_unavailable", scanned: 0, deleted: 0, cursor };
+      }
+    } else {
+      const query = openCodeDb.prepare("SELECT 1 FROM session WHERE id = ? LIMIT 1");
+      sessionExists = (id) => !!query.get(id);
+    }
     const cutoff = now - safetyAgeMs;
     const candidateSourceSql = getOpenCodeSessionScopedCandidateSourceSql(harness);
     const candidates = db.prepare(`SELECT session_id
@@ -1263,39 +2112,56 @@ function sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCod
                    )
                  ORDER BY session_id ASC
                  LIMIT ?`).all(cursor, cutoff, batchSize);
-    const sessionExists = openCodeDb.prepare("SELECT 1 FROM session WHERE id = ? LIMIT 1");
-    const missingSessionIds = candidates.filter((candidate) => !sessionExists.get(candidate.session_id)).map((candidate) => candidate.session_id);
+    const missingSessionIds = candidates.filter((candidate) => !sessionExists(candidate.session_id)).map((candidate) => candidate.session_id);
     const nextCursor = candidates.length < batchSize ? "" : candidates[candidates.length - 1]?.session_id ?? cursor;
     const completedAt = candidates.length < batchSize ? now : null;
-    db.exec("BEGIN IMMEDIATE");
-    const transactionStartedAt = performance.now();
-    let committed = false;
     let deleted = 0;
-    try {
-      const stillEligible = db.prepare(`SELECT 1
-                 FROM (${candidateSourceSql}) AS session_candidates
-                 WHERE session_id = ?
-                   AND NOT EXISTS (
-                       SELECT 1
-                       FROM message_history_index
-                       WHERE message_history_index.session_id = session_candidates.session_id
-                          AND message_history_index.harness = '${harness}'
-                         AND message_history_index.updated_at > ?
-                   )
-                 LIMIT 1`);
-      const eligibleSessionIds = missingSessionIds.filter((sessionId) => !sessionExists.get(sessionId) && stillEligible.get(sessionId, cutoff));
-      deleted = deleteSessionScopedRows(db, eligibleSessionIds, harness);
-      persistMessageHistoryOrphanSweepState(db, nextCursor, completedAt, harness);
-      db.exec("COMMIT");
-      committed = true;
-      logSlowWriteTransaction("message_index_orphan_sweep", transactionStartedAt);
-    } finally {
-      if (!committed) {
+    let slices = 0;
+    const stillEligible = db.prepare(`SELECT 1 WHERE NOT EXISTS (
+                SELECT 1 FROM message_history_index
+                WHERE session_id = ? AND harness = '${harness}' AND updated_at > ?
+            )`);
+    for (const sessionId of missingSessionIds) {
+      let complete = false;
+      do {
+        let removed = 0;
+        db.exec("BEGIN IMMEDIATE");
+        const transactionStartedAt = performance.now();
+        let committed = false;
         try {
-          db.exec("ROLLBACK");
-        } catch {}
-      }
+          const hostStillMissing = v2Reader ? !v2Reader.sessionExists(sessionId) : !sessionExists(sessionId);
+          if (hostStillMissing && stillEligible.get(sessionId, cutoff)) {
+            const slice = deleteSessionScopedRowsSlice(db, sessionId, harness);
+            removed = slice.deleted;
+            complete = slice.complete;
+          } else
+            complete = true;
+          db.exec("COMMIT");
+          committed = true;
+          logSlowWriteTransaction("message_index_orphan_sweep", transactionStartedAt);
+        } finally {
+          if (!committed) {
+            try {
+              db.exec("ROLLBACK");
+            } catch {}
+          }
+        }
+        deleted += removed;
+        if (removed)
+          clearLkgRecoveryFence(sessionId);
+        yield;
+        if (++slices >= Math.max(1, options.maxSlices ?? 512)) {
+          return {
+            status: "swept",
+            scanned: candidates.length,
+            deleted,
+            cursor,
+            partial: true
+          };
+        }
+      } while (!complete);
     }
+    persistMessageHistoryOrphanSweepState(db, nextCursor, completedAt, harness);
     return {
       status: "swept",
       scanned: candidates.length,
@@ -1303,11 +2169,24 @@ function sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCod
       cursor: nextCursor
     };
   } finally {
+    v2Reader?.close();
     closeQuietly(openCodeDb);
   }
 }
-function sweepOrphanedOpenCodeMessageIndexes2(db, openReadableOpenCodeDb, options = {}) {
-  return withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(() => sweepOrphanedOpenCodeMessageIndexesInBackground(db, openReadableOpenCodeDb, options)));
+async function sweepOrphanedOpenCodeMessageIndexesCooperatively2(db, openSource, options = {}) {
+  return withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(async () => {
+    const sweep = sweepOrphanedOpenCodeMessageIndexesInBackground(db, openSource, options);
+    try {
+      for (;; ) {
+        const step = sweep.next();
+        if (step.done)
+          return step.value;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
+    } finally {
+      sweep.return({ status: "source_unavailable", scanned: 0, deleted: 0, cursor: "" });
+    }
+  }));
 }
 
-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_BYTES2, messageIndexSkipKey2, toMessageIndexSource2, getMessageIndexSourceIdentity2, isMessageIndexSourceCurrent2, getLastIndexedOrdinal2, getIndexedMessageCorpusSize2, markMessageIndexDirty2, getMessageIndexReconciliationStartOrdinal2, isMessageIndexReconciledThrough2, deleteIndexedMessage2, clearIndexedMessagesInTransaction2, clearIndexedMessages2, getIndexableContent2, indexSingleMessage2, indexMessagesAfterOrdinal2, indexSourcesAfterOrdinal2, sweepOrphanedOpenCodeMessageIndexes2 };
+export { BoundedSessionMap, advanceSessionActivity, observeSessionActivity, backfillSessionActivity, clearCompressionDepth, clearCompressionDepthRange, LkgRecoveryFenceError, clearLkgFenceProcessState, lkgServedArrayDigest, hasCleanLkgRecoveryFence, lkgFenceRequiresRebuild, lkgRecoveryFenceUnclean, dirtyLkgRecoveryRevision, ownsLkgDirtyFence, invalidateCleanLkgRecoveryFence, prepareLkgCaptureFence, certifyCommittedLkgCapture, markLkgRecoveryDirty, commitLkgWithRecoveryFence, clearLkgRecoveryFence, cleanSearchText, keywordRelevance, matchedSearchSnippet, gaDatabasePath, RAW_MESSAGE_TYPES, V2StoreReaderPool, V2StoreReader, deleteSessionScopedRows, MESSAGE_INDEX_MAX_FTS_BYTES2, messageIndexSkipKey2, toMessageIndexSource2, getMessageIndexSourceIdentity2, isMessageIndexSourceCurrent2, getLastIndexedOrdinal2, getIndexedMessageCorpusSize2, markMessageIndexDirty2, getMessageIndexReconciliationStartOrdinal2, isMessageIndexReconciledThrough2, deleteIndexedMessage2, clearIndexedMessagesInTransaction2, clearIndexedMessages2, getIndexableContent2, indexSingleMessage2, indexMessagesAfterOrdinal2, indexSourcesAfterOrdinal2, sweepOrphanedOpenCodeMessageIndexesCooperatively2 };