session-steward 0.10.1 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.10.2] - 2026-09-07
+
+### Fixed
+
+- Codex cleanup now removes every rollout for a session, clears its memory jobs, and refreshes consolidated memory when needed.
+
 ## [0.10.1] - 2026-09-03
 
 ### Fixed
@@ -149,6 +155,7 @@
 - Support for custom Codex home folders and a saved folder preference.
 - Streaming and bounded-memory discovery for large session collections and transcripts.
 
+[0.10.2]: https://github.com/mallikcheripally/session-steward/compare/v0.10.1...v0.10.2
 [0.10.1]: https://github.com/mallikcheripally/session-steward/compare/v0.10.0...v0.10.1
 [0.10.0]: https://github.com/mallikcheripally/session-steward/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/mallikcheripally/session-steward/compare/v0.8.0...v0.9.0

package/lib/providers/codex/database-families.mjs

@@ -30,7 +30,28 @@ const SCHEMA_REQUIREMENTS = Object.freeze({
     fallback: "memories_1.sqlite",
     pattern: /^memories_(\d+)\.sqlite$/u,
     required: false,
-    tables: [{ name: "stage1_outputs", requiredColumns: ["thread_id"] }],
+    tables: [
+      { name: "stage1_outputs", requiredColumns: ["thread_id"] },
+      {
+        name: "jobs",
+        optional: true,
+        requiredColumns: [
+          "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",
+        ],
+      },
+    ],
   },
   goals: {
     fallback: "goals_1.sqlite",

package/lib/providers/codex/store.mjs

@@ -4,6 +4,7 @@ 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 {
@@ -142,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;
     }
   }
@@ -163,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 {
@@ -178,7 +206,8 @@ async function readFirstLine(filePath) {
     }
   } finally {
     interfaceHandle.close();
-    stream.destroy();
+    input.destroy();
+    source.destroy();
   }
 
   return "";
@@ -207,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 = "";
@@ -261,7 +292,8 @@ async function parseTranscriptFallback(filePath) {
     }
   } finally {
     interfaceHandle.close();
-    stream.destroy();
+    input.destroy();
+    source.destroy();
   }
 
   return {
@@ -603,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)));
 
@@ -801,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,
   };
 }
@@ -1257,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;
@@ -1275,7 +1334,12 @@ async function indexTranscriptHeaders(transcriptDirectories) {
     }
   }
 
-  return headersById;
+  return {
+    headersByThreadId,
+    pathsByThreadId,
+    rolloutIdsByThreadId,
+    rolloutReferencesById,
+  };
 }
 
 function getTranscriptChildrenByParentId(transcriptHeaders) {
@@ -1322,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];
 
@@ -1527,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,
   };
 }
 
@@ -1915,6 +1987,11 @@ const THREAD_HISTORY_TABLES_WITH_REALTIME = Object.freeze([
   "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
@@ -1922,9 +1999,112 @@ function threadHistoryTables(databasePath) {
     : 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();
@@ -1945,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)
@@ -2008,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))
@@ -2020,7 +2265,7 @@ export async function planSessionDeletion({ recordIds, store }) {
       : 0), 0);
   const threadHistoryRowCount = (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean))
     .reduce((total, databasePath) => total + threadHistoryTables(databasePath).reduce((databaseTotal, tableName) =>
-      databaseTotal + countRowsForIds(databasePath, tableName, "thread_id", deletionIds), 0), 0);
+      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)),
@@ -2038,6 +2283,9 @@ export async function planSessionDeletion({ recordIds, store }) {
     historyMatchCount: historyMatches.count,
     ids: deletionIds,
     logRowCount,
+    memoryConsolidations,
+    memoryJobRowCount,
+    memoryOutputRowCount,
     memoryRowCount,
     queueRowCount,
     queueRevisionRowCount,
@@ -2049,6 +2297,7 @@ export async function planSessionDeletion({ recordIds, store }) {
     stateTargets,
     transcriptBytes,
     transcriptFileCount,
+    threadHistoryIds,
     threadHistoryRowCount,
     transcriptPaths,
   };
@@ -2164,12 +2413,31 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
   }
   for (const databasePath of store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath].filter(Boolean)) {
     for (const tableName of threadHistoryTables(databasePath)) {
-      fingerprintRowsForIds(hash, databasePath, tableName, "thread_id", plan.ids);
+      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);
@@ -2675,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) {
@@ -2705,7 +2976,7 @@ export async function executeSessionDeletion({
     if (store.hasThreadHistoryDatabase) {
       for (const databasePath of store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]) {
         executeTransaction(databasePath, threadHistoryTables(databasePath).flatMap((tableName) =>
-          [...deleteStatements(tableName, "thread_id", plan.ids)]));
+          [...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 }))) {
@@ -3056,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) =>
@@ -3080,7 +3360,13 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
   const remainingThreadHistoryRecords = store.hasThreadHistoryDatabase
     ? (store.threadHistoryDatabasePaths ?? [store.threadHistoryDatabasePath]).flatMap((databasePath) =>
       threadHistoryTables(databasePath).flatMap((tableName) =>
-        findRowsForIds(databasePath, tableName, "thread_id", plan.ids, { limitOne: true })))
+        findRowsForIds(
+          databasePath,
+          tableName,
+          "thread_id",
+          plan.threadHistoryIds ?? plan.ids,
+          { limitOne: true },
+        )))
     : [];
   const [sessionIndexMatches, historyMatches] = await Promise.all([
     inspectJsonlMatches(
@@ -3124,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 &&
@@ -3138,6 +3425,7 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
     remainingHistoryEntries,
     remainingHistoryEntryCount: historyMatches.count,
     remainingLogRecords,
+    missingMemoryConsolidations,
     remainingMemoryRecords,
     remainingQueueRecords,
     remainingThreadHistoryRecords,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "session-steward",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Codex and Claude Code session manager - browse, back up, and delete old sessions. Local browser UI + CLI.",
   "license": "MIT",
   "author": "Mallik Cheripally",