session-steward 0.10.0 → 0.10.2

package/lib/providers/codex/store.mjs

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
 import { constants as fsConstants, createReadStream } from "node:fs";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import readline from "node:readline";
+import { createZstdDecompress } from "node:zlib";
 
 import { measurePath } from "../../storage/files.mjs";
 import {
@@ -141,7 +143,7 @@ async function* findTranscriptFiles(rootDirectory) {
       continue;
     }
 
-    if (entry.isFile() && /^rollout-.*\.jsonl$/u.test(entry.name)) {
+    if (entry.isFile() && /^rollout-.*\.jsonl(?:\.zst)?$/u.test(entry.name)) {
       yield resolvedPath;
     }
   }
@@ -162,13 +164,40 @@ function isContainedPath(rootDirectory, candidatePath) {
   return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
 }
 
+function createTranscriptTextStream(filePath) {
+  const source = createReadStream(filePath);
+
+  if (!filePath.endsWith(".zst")) {
+    source.setEncoding("utf8");
+    return { input: source, source };
+  }
+
+  const input = createZstdDecompress();
+  input.setEncoding("utf8");
+  source.on("error", (error) => input.destroy(error));
+  source.pipe(input);
+  return { input, source };
+}
+
+function rolloutIdFromPath(filePath) {
+  return path.basename(filePath).match(
+    /([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})\.jsonl(?:\.zst)?$/iu,
+  )?.[1]?.toLowerCase() ?? null;
+}
+
+function rolloutSiblingPath(filePath) {
+  return filePath.endsWith(".jsonl.zst")
+    ? filePath.slice(0, -4)
+    : filePath.endsWith(".jsonl")
+      ? `${filePath}.zst`
+      : null;
+}
+
 async function readFirstLine(filePath) {
-  const stream = createReadStream(filePath, {
-    encoding: "utf8",
-  });
+  const { input, source } = createTranscriptTextStream(filePath);
   const interfaceHandle = readline.createInterface({
     crlfDelay: Infinity,
-    input: stream,
+    input,
   });
 
   try {
@@ -177,7 +206,8 @@ async function readFirstLine(filePath) {
     }
   } finally {
     interfaceHandle.close();
-    stream.destroy();
+    input.destroy();
+    source.destroy();
   }
 
   return "";
@@ -206,19 +236,21 @@ async function parseTranscriptHeader(filePath) {
     cwd: payload.cwd ?? "",
     filePath,
     forkedFromId: payload.forked_from_id ?? null,
+    historyBaseId: payload.history_base?.thread_id
+      ? String(payload.history_base.thread_id)
+      : null,
     id: payload.id,
     parentThreadId: subagentParentId,
+    rolloutId: rolloutIdFromPath(filePath),
     timestampMs: toTimestampMs(payload.timestamp),
   };
 }
 
 async function parseTranscriptFallback(filePath) {
-  const stream = createReadStream(filePath, {
-    encoding: "utf8",
-  });
+  const { input, source } = createTranscriptTextStream(filePath);
   const interfaceHandle = readline.createInterface({
     crlfDelay: Infinity,
-    input: stream,
+    input,
   });
   let firstUserMessage = "";
   let latestThreadName = "";
@@ -260,7 +292,8 @@ async function parseTranscriptFallback(filePath) {
     }
   } finally {
     interfaceHandle.close();
-    stream.destroy();
+    input.destroy();
+    source.destroy();
   }
 
   return {
@@ -602,7 +635,8 @@ export async function loadSessionStore({ codexHome }) {
   }
   const threadRows = [...threadRowsById.values()];
   const spawnEdges = [...spawnEdgesByKey.values()];
-  const transcriptHeaders = await indexTranscriptHeaders(paths.transcriptDirectories);
+  const transcriptIndex = await indexTranscripts(paths.transcriptDirectories);
+  const transcriptHeaders = transcriptIndex.headersByThreadId;
 
   const discoveryIds = new Set(threadRows.map((threadRow) => String(threadRow.id)));
 
@@ -800,6 +834,9 @@ export async function loadSessionStore({ codexHome }) {
     threadHistoryDatabasePaths: paths.threadHistoryDatabasePaths,
     goalsDatabasePaths: paths.goalsDatabasePaths,
     transcriptHeaders,
+    transcriptPathsByThreadId: transcriptIndex.pathsByThreadId,
+    rolloutIdsByThreadId: transcriptIndex.rolloutIdsByThreadId,
+    rolloutReferencesById: transcriptIndex.rolloutReferencesById,
     historyPath: paths.historyPath,
   };
 }
@@ -1256,17 +1293,40 @@ async function getStoreAvailability(paths) {
   };
 }
 
-async function indexTranscriptHeaders(transcriptDirectories) {
-  const headersById = new Map();
+async function indexTranscripts(transcriptDirectories) {
+  const headersByThreadId = new Map();
+  const pathsByThreadId = new Map();
+  const rolloutIdsByThreadId = new Map();
+  const rolloutReferencesById = new Map();
 
   for (const transcriptDirectory of transcriptDirectories) {
     for await (const transcriptFile of findTranscriptFiles(transcriptDirectory)) {
       try {
         const header = await parseTranscriptHeader(transcriptFile);
-        const current = header?.id ? headersById.get(String(header.id)) : null;
+        if (!header?.id) continue;
+        const threadId = String(header.id);
+        const current = headersByThreadId.get(threadId);
+
+        if (!current || header.filePath > current.filePath) {
+          headersByThreadId.set(threadId, { ...header, id: threadId });
+        }
 
-        if (header?.id && (!current || header.filePath > current.filePath)) {
-          headersById.set(String(header.id), { ...header, id: String(header.id) });
+        const transcriptPaths = pathsByThreadId.get(threadId) ?? new Set();
+        transcriptPaths.add(header.filePath);
+        pathsByThreadId.set(threadId, transcriptPaths);
+
+        if (header.rolloutId) {
+          const rolloutIds = rolloutIdsByThreadId.get(threadId) ?? new Set();
+          rolloutIds.add(header.rolloutId);
+          rolloutIdsByThreadId.set(threadId, rolloutIds);
+
+          const existingReference = rolloutReferencesById.get(header.rolloutId);
+          if (!existingReference || (!existingReference.historyBaseId && header.historyBaseId)) {
+            rolloutReferencesById.set(header.rolloutId, {
+              historyBaseId: header.historyBaseId,
+              threadId,
+            });
+          }
         }
       } catch {
         continue;
@@ -1274,7 +1334,12 @@ async function indexTranscriptHeaders(transcriptDirectories) {
     }
   }
 
-  return headersById;
+  return {
+    headersByThreadId,
+    pathsByThreadId,
+    rolloutIdsByThreadId,
+    rolloutReferencesById,
+  };
 }
 
 function getTranscriptChildrenByParentId(transcriptHeaders) {
@@ -1321,10 +1386,11 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     throw new Error("Select at least one session.");
   }
 
-  const [availability, transcriptHeaders] = await Promise.all([
+  const [availability, transcriptIndex] = await Promise.all([
     getStoreAvailability(paths),
-    indexTranscriptHeaders(paths.transcriptDirectories),
+    indexTranscripts(paths.transcriptDirectories),
   ]);
+  const transcriptHeaders = transcriptIndex.headersByThreadId;
   const transcriptChildrenByParentId = getTranscriptChildrenByParentId(transcriptHeaders);
   const pendingIds = [...selectedIds];
 
@@ -1526,6 +1592,13 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     transcriptHeaders: new Map(
       [...transcriptHeaders].filter(([id]) => relevantIds.has(id)),
     ),
+    transcriptPathsByThreadId: new Map(
+      [...transcriptIndex.pathsByThreadId].filter(([id]) => relevantIds.has(id)),
+    ),
+    rolloutIdsByThreadId: new Map(
+      [...transcriptIndex.rolloutIdsByThreadId].filter(([id]) => relevantIds.has(id)),
+    ),
+    rolloutReferencesById: transcriptIndex.rolloutReferencesById,
   };
 }
 
@@ -1903,9 +1976,135 @@ function* deleteStatements(tableName, columnName, ids) {
   }
 }
 
+const REQUIRED_THREAD_HISTORY_TABLES = Object.freeze([
+  "thread_items",
+  "thread_turns",
+  "thread_history_projection_state",
+]);
+const THREAD_HISTORY_TABLES_WITH_REALTIME = Object.freeze([
+  "thread_items",
+  "thread_realtime_items",
+  "thread_turns",
+  "thread_history_projection_state",
+]);
+const MEMORY_STAGE1_JOB_KIND = "memory_stage1";
+const MEMORY_GLOBAL_JOB_KIND = "memory_consolidate_global";
+const MEMORY_GLOBAL_JOB_KEY = "global";
+const MEMORY_JOB_RETRY_COUNT = 3;
+const MEMORY_DELETE_IDS_TABLE = "session_steward_memory_delete_ids";
+
+function threadHistoryTables(databasePath) {
+  return inspectSqliteTable(databasePath, "thread_realtime_items").exists
+    ? THREAD_HISTORY_TABLES_WITH_REALTIME
+    : REQUIRED_THREAD_HISTORY_TABLES;
+}
+
+function memorySchema(databasePath) {
+  const jobs = inspectSqliteTable(databasePath, "jobs");
+  const stage1Outputs = inspectSqliteTable(databasePath, "stage1_outputs");
+
+  return {
+    hasJobs: jobs.exists,
+    hasSelectedForPhase2: stage1Outputs.columns?.includes("selected_for_phase2") ?? false,
+  };
+}
+
+function countMemoryJobsForIds(databasePath, ids) {
+  if (!memorySchema(databasePath).hasJobs) return 0;
+  return [...batches(ids)].reduce((total, idBatch) => total + Number(queryRows(
+    databasePath,
+    `select count(*) as count from jobs where kind = ? and job_key in (${placeholders(idBatch)})`,
+    [MEMORY_STAGE1_JOB_KIND, ...idBatch],
+  )[0]?.count ?? 0), 0);
+}
+
+function findMemoryJobsForIds(databasePath, ids) {
+  if (!memorySchema(databasePath).hasJobs) return [];
+  return [...batches(ids)].flatMap((idBatch) => queryRows(
+    databasePath,
+    `select * from jobs where kind = ? and job_key in (${placeholders(idBatch)})`,
+    [MEMORY_STAGE1_JOB_KIND, ...idBatch],
+  ));
+}
+
+function memoryConsolidationWatermark(databasePath) {
+  if (!memorySchema(databasePath).hasJobs) return null;
+  const row = queryRows(
+    databasePath,
+    "select input_watermark from jobs where kind = ? and job_key = ? limit 1",
+    [MEMORY_GLOBAL_JOB_KIND, MEMORY_GLOBAL_JOB_KEY],
+  )[0];
+  return row ? Number(row.input_watermark ?? 0) : null;
+}
+
+function needsMemoryConsolidation(databasePath, ids) {
+  const schema = memorySchema(databasePath);
+  if (!schema.hasJobs || !schema.hasSelectedForPhase2) return false;
+
+  return [...batches(ids)].some((idBatch) => Number(queryRows(
+    databasePath,
+    `select count(*) as count from stage1_outputs where selected_for_phase2 != 0 and thread_id in (${placeholders(idBatch)})`,
+    idBatch,
+  )[0]?.count ?? 0) > 0);
+}
+
+function memoryDeletionStatements(databasePath, ids, inputWatermark) {
+  const schema = memorySchema(databasePath);
+  const statements = [
+    { sql: `create temp table ${MEMORY_DELETE_IDS_TABLE} (thread_id text primary key) without rowid` },
+    ...[...batches(ids)].map((idBatch) => ({
+      parameters: idBatch,
+      sql: `insert into ${MEMORY_DELETE_IDS_TABLE} (thread_id) values ${idBatch.map(() => "(?)").join(", ")}`,
+    })),
+  ];
+
+  if (schema.hasJobs && schema.hasSelectedForPhase2) {
+    statements.push({
+      parameters: [
+        MEMORY_GLOBAL_JOB_KIND,
+        MEMORY_GLOBAL_JOB_KEY,
+        MEMORY_JOB_RETRY_COUNT,
+        inputWatermark,
+      ],
+      sql: `insert into jobs (
+        kind, job_key, status, worker_id, ownership_token, started_at, finished_at,
+        lease_until, retry_at, retry_remaining, last_error, input_watermark,
+        last_success_watermark
+      )
+      select ?, ?, 'pending', null, null, null, null, null, null, ?, null, ?, 0
+      where exists (
+        select 1 from stage1_outputs
+        where selected_for_phase2 != 0
+          and thread_id in (select thread_id from ${MEMORY_DELETE_IDS_TABLE})
+      )
+      on conflict(kind, job_key) do update set
+        status = case when jobs.status = 'running' then 'running' else 'pending' end,
+        retry_at = case when jobs.status = 'running' then jobs.retry_at else null end,
+        retry_remaining = max(jobs.retry_remaining, excluded.retry_remaining),
+        input_watermark = case
+          when excluded.input_watermark > coalesce(jobs.input_watermark, 0)
+            then excluded.input_watermark
+          else coalesce(jobs.input_watermark, 0) + 1
+        end`,
+    });
+  }
+
+  statements.push({
+    sql: `delete from stage1_outputs where thread_id in (select thread_id from ${MEMORY_DELETE_IDS_TABLE})`,
+  });
+  if (schema.hasJobs) {
+    statements.push({
+      parameters: [MEMORY_STAGE1_JOB_KIND],
+      sql: `delete from jobs where kind = ? and job_key in (select thread_id from ${MEMORY_DELETE_IDS_TABLE})`,
+    });
+  }
+  statements.push({ sql: `drop table ${MEMORY_DELETE_IDS_TABLE}` });
+  return statements;
+}
+
 export async function planSessionDeletion({ recordIds, store }) {
   const idsToDelete = new Set();
-  const pendingIds = [...recordIds];
+  const pendingIds = recordIds.map(String);
 
   while (pendingIds.length > 0) {
     const currentId = pendingIds.shift();
@@ -1926,9 +2125,55 @@ export async function planSessionDeletion({ recordIds, store }) {
     .map((id) => store.recordsById.get(id))
     .filter(Boolean)
     .sort((left, right) => left.displayName.localeCompare(right.displayName));
-  const transcriptPaths = selectedRecords
-    .map((record) => record.rolloutPath)
-    .filter(Boolean);
+  const deletionRolloutIds = new Set();
+
+  for (const id of deletionIds) {
+    for (const rolloutId of store.rolloutIdsByThreadId?.get(id) ?? []) {
+      deletionRolloutIds.add(rolloutId);
+    }
+  }
+  const threadHistoryIds = [...new Set([...deletionIds, ...deletionRolloutIds])];
+
+  const externalHistoryReferences = [];
+
+  for (const [rolloutId, reference] of store.rolloutReferencesById ?? []) {
+    if (
+      reference.historyBaseId &&
+      deletionRolloutIds.has(reference.historyBaseId) &&
+      !deletionRolloutIds.has(rolloutId)
+    ) {
+      externalHistoryReferences.push({ rolloutId, ...reference });
+    }
+  }
+
+  if (externalHistoryReferences.length > 0) {
+    const error = new Error(
+      "Another Codex session still depends on the selected session history. Select the related session too, or keep both.",
+    );
+    error.code = "CODEX_EXTERNAL_ROLLOUT_REFERENCE";
+    error.references = externalHistoryReferences;
+    throw error;
+  }
+
+  const transcriptPathSet = new Set(deletionIds.flatMap((id) => [
+    ...(store.transcriptPathsByThreadId?.get(id) ?? []),
+    store.recordsById.get(id)?.rolloutPath,
+  ]).filter(Boolean));
+  const transcriptDirectories = getCodexPaths(store.codexHome).transcriptDirectories;
+
+  for (const transcriptPath of [...transcriptPathSet]) {
+    const siblingPath = rolloutSiblingPath(transcriptPath);
+    if (
+      siblingPath &&
+      rolloutIdFromPath(transcriptPath) &&
+      transcriptDirectories.some((directory) => isContainedPath(directory, transcriptPath)) &&
+      await pathExists(siblingPath)
+    ) {
+      transcriptPathSet.add(siblingPath);
+    }
+  }
+
+  const transcriptPaths = [...transcriptPathSet].sort();
   const missingTranscriptPaths = selectedRecords
     .filter((record) => record.rolloutMissing)
     .map((record) => record.rolloutPath)
@@ -1989,8 +2234,27 @@ export async function planSessionDeletion({ recordIds, store }) {
       : 0), 0);
   const logRowCount = (store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean))
     .reduce((total, databasePath) => total + countRowsForIds(databasePath, "logs", "thread_id", deletionIds), 0);
-  const memoryRowCount = (store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean))
-    .reduce((total, databasePath) => total + countRowsForIds(databasePath, "stage1_outputs", "thread_id", deletionIds), 0);
+  const memoryDatabasePaths = store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean);
+  const memoryOutputRowCount = memoryDatabasePaths.reduce(
+    (total, databasePath) => total + countRowsForIds(
+      databasePath,
+      "stage1_outputs",
+      "thread_id",
+      deletionIds,
+    ),
+    0,
+  );
+  const memoryJobRowCount = memoryDatabasePaths.reduce(
+    (total, databasePath) => total + countMemoryJobsForIds(databasePath, deletionIds),
+    0,
+  );
+  const memoryConsolidations = memoryDatabasePaths
+    .filter((databasePath) => needsMemoryConsolidation(databasePath, deletionIds))
+    .map((databasePath) => ({
+      databasePath,
+      inputWatermark: memoryConsolidationWatermark(databasePath),
+    }));
+  const memoryRowCount = memoryOutputRowCount + memoryJobRowCount;
   const goalRowCount = (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean))
     .reduce((total, databasePath) => total + countRowsForIds(databasePath, "thread_goals", "thread_id", deletionIds), 0);
   const queueRowCount = (store.queueDatabasePaths ?? [store.queueDatabasePath].filter(Boolean))
@@ -2000,12 +2264,8 @@ export async function planSessionDeletion({ recordIds, store }) {
       ? countRowsForIds(databasePath, "queued_thread_revisions", "thread_id", deletionIds)
       : 0), 0);
   const threadHistoryRowCount = (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean))
-    .reduce((total, databasePath) => total + [
-      "thread_items",
-      "thread_turns",
-      "thread_history_projection_state",
-    ].reduce((databaseTotal, tableName) =>
-      databaseTotal + countRowsForIds(databasePath, tableName, "thread_id", deletionIds), 0), 0);
+    .reduce((total, databasePath) => total + threadHistoryTables(databasePath).reduce((databaseTotal, tableName) =>
+      databaseTotal + countRowsForIds(databasePath, tableName, "thread_id", threadHistoryIds), 0), 0);
   const stateTargets = (store.stateDatabases ?? [{ path: store.stateDatabasePath }]).map((database) => ({
     database,
     ids: findRowsForIds(database.path, "threads", "id", deletionIds).map((row) => String(row.id)),
@@ -2023,6 +2283,9 @@ export async function planSessionDeletion({ recordIds, store }) {
     historyMatchCount: historyMatches.count,
     ids: deletionIds,
     logRowCount,
+    memoryConsolidations,
+    memoryJobRowCount,
+    memoryOutputRowCount,
     memoryRowCount,
     queueRowCount,
     queueRevisionRowCount,
@@ -2034,6 +2297,7 @@ export async function planSessionDeletion({ recordIds, store }) {
     stateTargets,
     transcriptBytes,
     transcriptFileCount,
+    threadHistoryIds,
     threadHistoryRowCount,
     transcriptPaths,
   };
@@ -2148,13 +2412,32 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
     }
   }
   for (const databasePath of store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean)) {
-    fingerprintRowsForIds(hash, databasePath, "thread_items", "thread_id", plan.ids);
-    fingerprintRowsForIds(hash, databasePath, "thread_turns", "thread_id", plan.ids);
-    fingerprintRowsForIds(hash, databasePath, "thread_history_projection_state", "thread_id", plan.ids);
+    for (const tableName of threadHistoryTables(databasePath)) {
+      fingerprintRowsForIds(
+        hash,
+        databasePath,
+        tableName,
+        "thread_id",
+        plan.threadHistoryIds ?? plan.ids,
+      );
+    }
   }
   if (scope === "deep") {
     for (const databasePath of store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) {
       fingerprintRowsForIds(hash, databasePath, "stage1_outputs", "thread_id", plan.ids);
+      if (memorySchema(databasePath).hasJobs) {
+        const jobKeys = (plan.memoryConsolidations ?? [])
+          .some((consolidation) => consolidation.databasePath === databasePath)
+          ? [...plan.ids, MEMORY_GLOBAL_JOB_KEY]
+          : plan.ids;
+        fingerprintRowsForIds(
+          hash,
+          databasePath,
+          "jobs",
+          "job_key",
+          jobKeys,
+        );
+      }
     }
     for (const databasePath of store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean)) {
       fingerprintRowsForIds(hash, databasePath, "thread_goals", "thread_id", plan.ids);
@@ -2220,6 +2503,108 @@ async function getAvailableDiskBytes(directoryPath) {
   return stats.bavail * stats.bsize;
 }
 
+const LOCK_PROBE_CONFLICT_EXIT_CODE = 75;
+const LOCK_PROBE_CONCURRENCY = 8;
+const LOCK_PROBE_TIMEOUT_MS = 5_000;
+const WINDOWS_LOCK_PROBE_SCRIPT = String.raw`
+$ErrorActionPreference = "Stop"
+$stream = $null
+try {
+  $stream = [System.IO.File]::Open(
+    $env:SESSION_STEWARD_WRITER_LOCK_PATH,
+    [System.IO.FileMode]::Open,
+    [System.IO.FileAccess]::ReadWrite,
+    ([System.IO.FileShare]::ReadWrite -bor [System.IO.FileShare]::Delete)
+  )
+  try {
+    $stream.Lock(0, 1)
+    $stream.Unlock(0, 1)
+    exit 0
+  } catch [System.IO.IOException] {
+    if (($_.Exception.HResult -band 0xffff) -eq 33) { exit 75 }
+    exit 70
+  }
+} catch [System.IO.FileNotFoundException] {
+  exit 66
+} catch [System.IO.DirectoryNotFoundException] {
+  exit 66
+} catch {
+  exit 70
+} finally {
+  if ($null -ne $stream) { $stream.Dispose() }
+}
+`;
+
+function runLockProbe(command, args, options = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let child;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve(result);
+    };
+    const timeout = setTimeout(() => {
+      child?.kill();
+      finish({ error: new Error("The writer-lock probe timed out."), exitCode: null });
+    }, LOCK_PROBE_TIMEOUT_MS);
+
+    try {
+      child = spawn(command, args, {
+        stdio: "ignore",
+        windowsHide: true,
+        ...options,
+      });
+    } catch (error) {
+      finish({ error, exitCode: null });
+      return;
+    }
+
+    child.once("error", (error) => finish({ error, exitCode: null }));
+    child.once("exit", (exitCode) => finish({ error: null, exitCode }));
+  });
+}
+
+async function probeWriterLock(lockPath) {
+  if (process.platform === "win32") {
+    const result = await runLockProbe(
+      "powershell.exe",
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", WINDOWS_LOCK_PROBE_SCRIPT],
+      {
+        env: { ...process.env, SESSION_STEWARD_WRITER_LOCK_PATH: lockPath },
+      },
+    );
+    if (result.exitCode === 0) return "free";
+    if (result.exitCode === LOCK_PROBE_CONFLICT_EXIT_CODE) return "held";
+    if (result.exitCode === 66) return "missing";
+    return "unknown";
+  }
+
+  let handle;
+  try {
+    handle = await fs.open(lockPath, "r+");
+  } catch (error) {
+    if (error?.code === "ENOENT") return "missing";
+    return "unknown";
+  }
+
+  try {
+    const command = process.platform === "darwin" ? "/usr/bin/lockf" : "flock";
+    const args = process.platform === "darwin"
+      ? ["-s", "-t", "0", "3"]
+      : ["-n", "-E", String(LOCK_PROBE_CONFLICT_EXIT_CODE), "3"];
+    const result = await runLockProbe(command, args, {
+      stdio: ["ignore", "ignore", "ignore", handle.fd],
+    });
+    if (result.exitCode === 0) return "free";
+    if (result.exitCode === LOCK_PROBE_CONFLICT_EXIT_CODE) return "held";
+    return "unknown";
+  } finally {
+    await handle.close();
+  }
+}
+
 async function findActiveThreadIds(store, ids) {
   if (!store.threadWriterLocksDirectory) return { available: false, ids: [] };
 
@@ -2231,20 +2616,48 @@ async function findActiveThreadIds(store, ids) {
     throw error;
   }
 
-  const lockedIds = new Set(entries
+  const lockPathsById = new Map(entries
     .filter((entry) => entry.isFile() && entry.name.endsWith(".lock"))
-    .map((entry) => entry.name.slice(0, -5)));
+    .map((entry) => {
+      const id = entry.name.slice(0, -5);
+      return [id, path.join(store.threadWriterLocksDirectory, entry.name)];
+    }));
+  const candidates = ids.filter((id) => lockPathsById.has(id));
+  const states = new Array(candidates.length);
+  let nextIndex = 0;
+  await Promise.all(Array.from(
+    { length: Math.min(LOCK_PROBE_CONCURRENCY, candidates.length) },
+    async () => {
+      while (nextIndex < candidates.length) {
+        const index = nextIndex;
+        nextIndex += 1;
+        const id = candidates[index];
+        states[index] = { id, state: await probeWriterLock(lockPathsById.get(id)) };
+      }
+    },
+  ));
   return {
     available: true,
-    ids: ids.filter((id) => lockedIds.has(id)),
+    ids: states.filter(({ state }) => state === "held").map(({ id }) => id),
+    unverifiedIds: states.filter(({ state }) => state === "unknown").map(({ id }) => id),
   };
 }
 
 function activeThreadError(ids) {
   const error = new Error(
     ids.length === 1
-      ? "Close the selected Codex session before cleanup."
-      : `Close the ${ids.length} selected Codex sessions that are still open before cleanup.`,
+      ? "Quit ChatGPT or Codex completely before cleaning up the selected Codex session."
+      : `Quit ChatGPT or Codex completely before cleaning up the ${ids.length} selected Codex sessions that are still open.`,
+  );
+  error.activeThreadIds = ids;
+  return error;
+}
+
+function unverifiedThreadError(ids) {
+  const error = new Error(
+    ids.length === 1
+      ? "Session Steward could not verify whether the selected Codex session is still open. Try cleanup again."
+      : `Session Steward could not verify whether ${ids.length} selected Codex sessions are still open. Try cleanup again.`,
   );
   error.activeThreadIds = ids;
   return error;
@@ -2287,6 +2700,7 @@ export async function preflightSessionDeletion({ availableDiskBytes, plan, scope
 
   const activeThreads = await findActiveThreadIds(store, plan.ids);
   if (activeThreads.ids.length > 0) throw activeThreadError(activeThreads.ids);
+  if (activeThreads.unverifiedIds?.length > 0) throw unverifiedThreadError(activeThreads.unverifiedIds);
 
   const deletedIdSet = new Set(plan.ids);
   const desktopStates = await Promise.all([
@@ -2515,6 +2929,9 @@ export async function executeSessionDeletion({
   if (activeThreads.ids.length > 0) {
     throw cleanupErrorWithBackup(activeThreadError(activeThreads.ids), backupDirectory);
   }
+  if (activeThreads.unverifiedIds?.length > 0) {
+    throw cleanupErrorWithBackup(unverifiedThreadError(activeThreads.unverifiedIds), backupDirectory);
+  }
 
   await reportProgress(onProgress, {
     canCancel: false,
@@ -2526,7 +2943,10 @@ export async function executeSessionDeletion({
   try {
     if (scope === "deep" && store.hasMemoryDatabase) {
       for (const databasePath of store.memoryDatabasePaths ?? [store.memoryDatabasePath]) {
-        executeTransaction(databasePath, deleteStatements("stage1_outputs", "thread_id", plan.ids));
+        executeTransaction(
+          databasePath,
+          memoryDeletionStatements(databasePath, plan.ids, Math.floor(Date.now() / 1_000)),
+        );
       }
     }
     if (scope === "deep" && store.hasGoalsDatabase) {
@@ -2555,11 +2975,8 @@ export async function executeSessionDeletion({
     }
     if (store.hasThreadHistoryDatabase) {
       for (const databasePath of store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]) {
-        executeTransaction(databasePath, [
-          ...deleteStatements("thread_items", "thread_id", plan.ids),
-          ...deleteStatements("thread_turns", "thread_id", plan.ids),
-          ...deleteStatements("thread_history_projection_state", "thread_id", plan.ids),
-        ]);
+        executeTransaction(databasePath, threadHistoryTables(databasePath).flatMap((tableName) =>
+          [...deleteStatements(tableName, "thread_id", plan.threadHistoryIds ?? plan.ids)]));
       }
     }
     for (const { database, ids } of plan.stateTargets ?? (store.stateDatabases ?? [{ path: store.stateDatabasePath }]).map((database) => ({ database, ids: plan.ids }))) {
@@ -2910,7 +3327,16 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
       : []);
   const remainingMemoryRecords = scope === "deep" && store.hasMemoryDatabase
     ? (store.memoryDatabasePaths ?? [store.memoryDatabasePath]).flatMap((databasePath) =>
-      findRowsForIds(databasePath, "stage1_outputs", "thread_id", plan.ids))
+      [
+        ...findRowsForIds(databasePath, "stage1_outputs", "thread_id", plan.ids),
+        ...findMemoryJobsForIds(databasePath, plan.ids),
+      ])
+    : [];
+  const missingMemoryConsolidations = scope === "deep"
+    ? (plan.memoryConsolidations ?? []).filter(({ databasePath, inputWatermark }) => {
+      const currentWatermark = memoryConsolidationWatermark(databasePath);
+      return currentWatermark === null || currentWatermark <= (inputWatermark ?? 0);
+    })
     : [];
   const remainingGoalRecords = scope === "deep" && store.hasGoalsDatabase
     ? (store.goalsDatabasePaths ?? [store.goalsDatabasePath]).flatMap((databasePath) =>
@@ -2932,11 +3358,15 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
     ])
     : [];
   const remainingThreadHistoryRecords = store.hasThreadHistoryDatabase
-    ? (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]).flatMap((databasePath) => [
-      ...findRowsForIds(databasePath, "thread_items", "thread_id", plan.ids, { limitOne: true }),
-      ...findRowsForIds(databasePath, "thread_turns", "thread_id", plan.ids, { limitOne: true }),
-      ...findRowsForIds(databasePath, "thread_history_projection_state", "thread_id", plan.ids, { limitOne: true }),
-    ])
+    ? (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]).flatMap((databasePath) =>
+      threadHistoryTables(databasePath).flatMap((tableName) =>
+        findRowsForIds(
+          databasePath,
+          tableName,
+          "thread_id",
+          plan.threadHistoryIds ?? plan.ids,
+          { limitOne: true },
+        )))
     : [];
   const [sessionIndexMatches, historyMatches] = await Promise.all([
     inspectJsonlMatches(
@@ -2980,6 +3410,7 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
       remainingThreads.length === 0 &&
       remainingDynamicTools.length === 0 &&
       remainingMemoryRecords.length === 0 &&
+      missingMemoryConsolidations.length === 0 &&
       remainingGoalRecords.length === 0 &&
       remainingLogRecords.length === 0 &&
       remainingQueueRecords.length === 0 &&
@@ -2994,6 +3425,7 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
     remainingHistoryEntries,
     remainingHistoryEntryCount: historyMatches.count,
     remainingLogRecords,
+    missingMemoryConsolidations,
     remainingMemoryRecords,
     remainingQueueRecords,
     remainingThreadHistoryRecords,