session-steward 0.10.1 → 0.10.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.10.3] - 2026-09-10
+
+### Fixed
+
+- Deleted Codex sessions no longer linger in the ChatGPT sidebar.
+- Claude cleanup now handles stale session markers, protects shared history, and removes leftover session files.
+
+## [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 +162,8 @@
 - Support for custom Codex home folders and a saved folder preference.
 - Streaming and bounded-memory discovery for large session collections and transcripts.
 
+[0.10.3]: https://github.com/mallikcheripally/session-steward/compare/v0.10.2...v0.10.3
+[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/claude-code/process-state.mjs

@@ -0,0 +1,73 @@
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { hostname } from "node:os";
+import { promisify } from "node:util";
+
+const runCommand = promisify(execFile);
+const PS_START = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{1,2} \d{2}:\d{2}:\d{2} \d{4}$/u;
+
+export function validProcessId(pid) {
+  return Number.isSafeInteger(pid) && pid > 1 && pid <= 2_147_483_647;
+}
+
+export async function localClaudePidDomain(platform = process.platform) {
+  if (platform === "darwin") return "darwin";
+  if (platform === "win32") return `win32:${hostname().toLowerCase()}`;
+  if (platform !== "linux") return null;
+  try {
+    const [machine, namespace] = await Promise.all([
+      fs.readFile("/etc/machine-id", "utf8"), fs.readlink("/proc/self/ns/pid"),
+    ]);
+    return `linux:${machine.trim()}:${namespace}`;
+  } catch {
+    return null;
+  }
+}
+
+// These are Claude's process identity tokens, not the session's startedAt:
+// UTC ps lstart on macOS/Linux, and Windows creation FILETIME in procStartFt.
+export async function readClaudeProcessStart(pid, { platform = process.platform, run = runCommand } = {}) {
+  if (!validProcessId(pid)) return null;
+  const windows = platform === "win32";
+  if (!windows && platform !== "darwin" && platform !== "linux") return null;
+  try {
+    const { stdout } = await run(windows ? "powershell.exe" : "ps", windows
+      ? ["-NoProfile", "-NonInteractive", "-Command", `$ErrorActionPreference='Stop'; (Get-Process -Id ${pid}).StartTime.ToUniversalTime().ToFileTimeUtc().ToString()`]
+      : ["-o", "lstart=", "-p", String(pid)], {
+      // PowerShell has a noticeably slower cold start than ps, especially under load.
+      encoding: "utf8", timeout: windows ? 10_000 : 1_000, maxBuffer: 4_096, windowsHide: true,
+      env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
+    });
+    return stdout.trim().replace(/\s+/gu, " ") || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function claudeProcessState(marker, {
+  platform = process.platform,
+  pidDomain,
+  kill = process.kill,
+  readStart = (pid) => readClaudeProcessStart(pid, { platform }),
+} = {}) {
+  if (!validProcessId(marker.pid)) return "unverified";
+  // A PID from another machine/namespace cannot be checked against this one.
+  if (marker.pidDomain !== undefined && marker.pidDomain !== pidDomain) return "unverified";
+  const running = () => {
+    try { kill(marker.pid, 0); return "active"; }
+    catch (error) { return error.code === "ESRCH" ? "inactive" : "unverified"; }
+  };
+  const state = running();
+  if (state !== "active") return state;
+  const expected = platform === "win32" ? marker.procStartFt : marker.procStart;
+  // Legacy records have no start token: a live PID must remain protected.
+  if (expected === undefined) return "active";
+  if (typeof expected !== "string") return "unverified";
+  const normalized = expected.trim().replace(/\s+/gu, " ");
+  const validToken = (value) => typeof value === "string" && (platform === "win32"
+    ? /^[1-9]\d{0,19}$/u.test(value) : PS_START.test(value) && Number.isFinite(Date.parse(`${value} UTC`)));
+  if (!validToken(normalized)) return "unverified";
+  const actual = await readStart(marker.pid);
+  if (!validToken(actual)) return running() === "inactive" ? "inactive" : "unverified";
+  return normalized === actual ? "active" : "inactive";
+}

package/lib/providers/claude-code/store.mjs

@@ -4,6 +4,7 @@ import { createReadStream, createWriteStream } from "node:fs";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { finished, pipeline } from "node:stream/promises";
+import lockfile from "proper-lockfile";
 
 import {
   expandHomePath,
@@ -12,19 +13,20 @@ import {
 } from "../../platform.mjs";
 import { measurePath } from "../../storage/files.mjs";
 import { readJsonlEntries, rewriteJsonlFile } from "../../storage/jsonl.mjs";
+import { claudeProcessState, localClaudePidDomain } from "./process-state.mjs";
 
 const PROVIDER_ID = "claude-code";
 const COMPATIBILITY_PROFILE = Object.freeze({
   id: "claude-local-store-2026-08",
   builtFor: {
-    claudeCli: ["2.1.199", "2.1.220", "2.1.228", "2.1.237"],
-    claudeDesktop: ["1.24012.9", "1.28929.0", "1.32885.1", "1.40609.0"],
+    claudeCli: ["2.1.199", "2.1.220", "2.1.228", "2.1.237", "2.1.267"],
+    claudeDesktop: ["1.24012.9", "1.28929.0", "1.32885.1", "1.40609.0", "1.49585.0"],
   },
 });
 const SUPPORTED_ENTRYPOINTS = new Set(["cli", "claude-desktop"]);
 const SHARED_DESKTOP_STATE_FILES = new Set(["scheduled-tasks.json"]);
 const KNOWN_TOP_LEVEL = new Set([
-  ".DS_Store", ".last-cleanup", ".last-update-result.json", "agents", "backups", "cache", "commands", "debug", "downloads", "file-history", "history.jsonl",
+  ".DS_Store", ".last-cleanup", ".last-update-result.json", "agents", "backups", "cache", "commands", "debug", "downloads", "file-history", "history.jsonl", "history.jsonl.lock",
   "ide", "paste-cache", "plans", "plugins", "projects", "session-env", "sessions", "settings.json",
   "settings.local.json", "shell-snapshots", "skills", "stats-cache.json", "tasks", "telemetry",
   "todos", "uploads", "usage-data", "mcp-needs-auth-cache.json", "session-steward-backups",
@@ -330,6 +332,26 @@ async function listDesktopStates(directory) {
   return { byCliSessionId, unlinked };
 }
 
+// Claude's project-level siblings. Do not use a broad session-ID prefix:
+// unknown suffixes and another session's files must remain untouched.
+function indexSessionSidecars(directory, entries) {
+  const byId = new Map();
+  for (const entry of entries) {
+    const id = /^(.*)\.(?:ccr-tip|precompact|desktop-released|dir-sync)\.json$/u.exec(entry.name)?.[1]
+      ?? /^(.*)-[0-9]{1,16}\.cast$/u.exec(entry.name)?.[1];
+    if (!id) continue;
+    const paths = byId.get(id) ?? [];
+    paths.push(path.join(directory, entry.name));
+    byId.set(id, paths);
+  }
+  return byId;
+}
+
+function sidecarsForTranscript(index, transcriptPath, id) {
+  // Conflicting transcript filenames/content do not establish ownership.
+  return path.basename(transcriptPath) === `${id}.jsonl` ? index.get(id) ?? [] : [];
+}
+
 async function discover(claudeHome, desktopDataHome) {
   const paths = getPaths(claudeHome, desktopDataHome);
   const desktop = await listDesktopStates(paths.desktopSessionsDirectory);
@@ -345,10 +367,12 @@ async function discover(claudeHome, desktopDataHome) {
     const projectDirectory = path.join(paths.projectsDirectory, projectEntry.name);
     let files;
     try { files = await fs.readdir(projectDirectory, { withFileTypes: true }); } catch { continue; }
+    const sidecars = indexSessionSidecars(projectDirectory, files);
     for (const file of files) {
       if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
       const fallbackId = file.name.slice(0, -6);
       const summary = await readTranscriptSummary(path.join(projectDirectory, file.name), fallbackId);
+      summary.sidecarPaths = sidecarsForTranscript(sidecars, summary.transcriptPath, summary.id);
       if (!SUPPORTED_ENTRYPOINTS.has(summary.entrypoint)) { unknown.push(summary.transcriptPath); continue; }
       const copies = summariesById.get(summary.id) ?? [];
       copies.push(summary); summariesById.set(summary.id, copies);
@@ -390,6 +414,7 @@ async function discover(claudeHome, desktopDataHome) {
       titleSource: cleanTitle(state?.title) ? "Desktop title" : (copies.find((item) => item.titleSource)?.titleSource || "session ID"),
       transcriptBytes: copies.reduce((sum, item) => sum + item.transcriptBytes, 0),
       transcriptPaths: copies.map((item) => item.transcriptPath),
+      sidecarPaths: copies.flatMap((item) => item.sidecarPaths),
       updatedAtMs: Math.max(...copies.map((item) => item.activityAtMs)),
     });
   }
@@ -486,6 +511,14 @@ export async function getSessionOverview({ claudeHome, desktopDataHome, refresh
       storageTargets.add(path.join(path.dirname(target), record.id));
     });
     record.desktopStatePaths.forEach((target) => storageTargets.add(target));
+    for (const target of record.sidecarPaths) {
+      // Unknown directory/symlink layouts are not part of the recognized size.
+      const stats = await fs.lstat(target).catch((error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      });
+      if (stats?.isFile()) storageTargets.add(target);
+    }
     storageTargets.add(path.join(store.paths.sessionEnvDirectory, record.id));
     storageTargets.add(path.join(store.paths.tasksDirectory, record.id));
     storageTargets.add(path.join(store.paths.debugDirectory, `${record.id}.txt`));
@@ -607,6 +640,15 @@ export async function planSessionDeletion({ recordIds, store }) {
   for (const record of records) {
     record.transcriptPaths.forEach((item) => selectedPaths.add(item));
     record.desktopStatePaths.forEach((item) => selectedPaths.add(item));
+    for (const target of record.sidecarPaths) {
+      const stats = await fs.lstat(target).catch((error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      });
+      if (!stats) continue;
+      if (!stats.isFile()) throw new Error("Cleanup stopped because a Claude session sidecar is not a regular file. It was left unchanged.");
+      selectedPaths.add(target);
+    }
     for (const candidate of [
       path.join(store.paths.sessionEnvDirectory, record.id),
       path.join(store.paths.tasksDirectory, record.id),
@@ -656,34 +698,79 @@ export async function planSessionDeletion({ recordIds, store }) {
   };
 }
 
-async function activeSessionIds(paths) {
+async function activeSessionIds(paths, selectedIds) {
   const active = new Set();
-  if (!(await exists(paths.sessionsDirectory))) return { active, detection: "unavailable" };
+  const unverified = new Set();
+  const selected = new Set(selectedIds);
+  const pidDomain = await localClaudePidDomain();
+  const buffer = Buffer.alloc(256 * 1024 + 1);
   const pending = [paths.sessionsDirectory];
   while (pending.length) {
     const current = pending.pop();
     let entries;
-    try { entries = await fs.readdir(current, { withFileTypes: true }); } catch { continue; }
+    try { entries = await fs.readdir(current, { withFileTypes: true }); } catch (error) {
+      if (error.code === "ENOENT") continue;
+      for (const id of selected) unverified.add(id);
+      continue;
+    }
     for (const entry of entries) {
       const target = path.join(current, entry.name);
       if (entry.isDirectory()) { pending.push(target); continue; }
-      const match = /([0-9a-f]{8}-[0-9a-f-]{27,})/iu.exec(entry.name);
-      if (match) active.add(match[1]);
-      if (!entry.name.endsWith(".json")) continue;
+      const nameId = /([0-9a-f]{8}-[0-9a-f-]{27,})/iu.exec(entry.name)?.[1];
+      const filenamePid = /^([1-9]\d*)\.json$/u.exec(entry.name)?.[1];
+      if (!entry.isFile()) {
+        if (selected.has(nameId)) unverified.add(nameId);
+        else if (filenamePid) for (const id of selected) unverified.add(id);
+        continue;
+      }
+      if (!entry.name.endsWith(".json")) {
+        if (selected.has(nameId)) unverified.add(nameId);
+        continue;
+      }
+      let parsed;
       try {
-        const parsed = JSON.parse(await fs.readFile(target, "utf8"));
-        const id = parsed.sessionId ?? parsed.session_id;
-        if (typeof id === "string" && !["stopped", "completed", "failed"].includes(parsed.status ?? parsed.state)) active.add(id);
-      } catch {}
+        // Registry metadata is small; do not read an arbitrary large file.
+        const handle = await fs.open(target, "r");
+        try {
+          const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+          if (bytesRead === buffer.length) throw new Error("Oversized session marker.");
+          parsed = JSON.parse(buffer.toString("utf8", 0, bytesRead));
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Invalid session marker.");
+        } finally { await handle.close(); }
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        if (selected.has(nameId)) unverified.add(nameId);
+        else if (filenamePid && await claudeProcessState({ pid: Number(filenamePid) }) !== "inactive") {
+          for (const id of selected) unverified.add(id);
+        }
+        continue;
+      }
+      const id = parsed.sessionId ?? parsed.session_id ?? nameId;
+      if (selected.has(nameId) && id !== nameId) unverified.add(nameId);
+      if (!selected.has(id)) continue;
+      const pid = parsed.pid ?? (filenamePid ? Number(filenamePid) : undefined);
+      if (filenamePid && parsed.pid !== undefined && parsed.pid !== Number(filenamePid)) {
+        unverified.add(id);
+        continue;
+      }
+      if (pid === undefined && ["stopped", "completed", "failed"].includes(parsed.status ?? parsed.state)) continue;
+      const state = await claudeProcessState({ ...parsed, pid }, { pidDomain });
+      if (state === "active") active.add(id);
+      if (state === "unverified") unverified.add(id);
     }
   }
-  return { active, detection: "available" };
+  return { active, unverified, detection: await exists(paths.sessionsDirectory) ? "available" : "unavailable" };
+}
+
+async function assertSelectedSessionsClosed(paths, ids) {
+  const result = await activeSessionIds(paths, ids);
+  if (result.active.size) throw new Error("Close the selected Claude sessions before cleanup.");
+  if (result.unverified.size) throw new Error("Could not verify whether the selected Claude sessions are closed. Their process markers could not be checked safely; retry cleanup after Claude has exited.");
+  return result;
 }
 
 export async function preflightSessionDeletion({ availableDiskBytes, plan, scope, store }) {
-  const active = await activeSessionIds(store.paths);
-  const selectedActive = plan.ids.filter((id) => active.active.has(id));
-  if (selectedActive.length) throw new Error("Close the selected Claude sessions before cleanup.");
+  const active = await assertSelectedSessionsClosed(store.paths, plan.ids);
   const deepBytes = scope === "deep" ? plan.deepFiles.reduce((sum, file) => sum + file.size, 0) : 0;
   const estimatedBackupBytes = plan.transcriptBytes + deepBytes + plan.historyMatchBytes + 4096;
   let diskBytes = availableDiskBytes;
@@ -784,7 +871,42 @@ async function backupHistoryRows(historyPath, destination, ids) {
   }
 }
 
-async function createBackup(plan, store, scope) {
+// Claude's prompt-history writer uses proper-lockfile with a 10-second stale
+// threshold. Use the same canonical path, directory lock and heartbeat rather
+// than Session Steward's separate mutation lock (which Claude does not know).
+async function lockHistory(historyPath) {
+  const canonicalPath = path.join(await fs.realpath(path.dirname(historyPath)), path.basename(historyPath));
+  const stats = await fs.lstat(canonicalPath).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (stats && !stats.isFile()) throw new Error("Claude prompt history is not a regular file. It was left unchanged.");
+  let compromised;
+  let released = false;
+  const release = await lockfile.lock(canonicalPath, {
+    realpath: false, // Restore also needs to lock history that does not exist yet.
+    stale: 10_000,
+    retries: { retries: 3, minTimeout: 50 },
+    onCompromised: (error) => { compromised = error; },
+  }).catch((error) => {
+    if (error.code === "ELOCKED") {
+      throw new Error("Claude prompt history is busy. Retry cleanup or restore in a moment.", { cause: error });
+    }
+    throw error;
+  });
+  return {
+    assertHeld() {
+      if (compromised) throw new Error("Claude prompt-history lock was lost. No further history changes were made.", { cause: compromised });
+    },
+    async release() {
+      if (released) return;
+      released = true;
+      if (!compromised) await release();
+    },
+  };
+}
+
+async function createBackup(plan, store, scope, acquireHistoryLock) {
   const backupDirectory = path.join(store.paths.backupRoot, `${new Date().toISOString().replaceAll(":", "-")}-${randomBytes(6).toString("hex")}`);
   const entries = [];
   await fs.mkdir(backupDirectory, { mode: 0o700, recursive: true });
@@ -802,6 +924,9 @@ async function createBackup(plan, store, scope) {
     }
     const sharedJsonl = [];
     if (plan.historyMatchCount) {
+      // Do not block other sessions while the large transcript copies run.
+      // Keep this lock from the history backup through its replacement.
+      await acquireHistoryLock();
       const backupRelative = path.join("shared", "history.jsonl");
       const destination = path.join(backupDirectory, backupRelative);
       await backupHistoryRows(store.paths.historyPath, destination, new Set(plan.ids));
@@ -832,21 +957,25 @@ async function createBackup(plan, store, scope) {
 export async function executeSessionDeletion({ onProgress = () => {}, plan, scope, shouldCancel = () => false, store }) {
   onProgress({ canCancel: true, message: "Creating recovery backup", phase: "backup", progress: 8 });
   let backupDirectory;
-  try {
-    backupDirectory = await createBackup(plan, store, scope);
-  } catch (error) {
-    error.mutationStarted = false;
-    throw error;
-  }
+  let historyLock;
   let mutationStarted = false;
   try {
+    backupDirectory = await createBackup(plan, store, scope, async () => {
+      historyLock = await lockHistory(store.paths.historyPath);
+    });
     if (shouldCancel()) { const error = new Error("Cleanup cancelled."); error.cancelled = true; error.backupDirectory = backupDirectory; error.mutationStarted = false; throw error; }
     onProgress({ canCancel: false, message: "Removing selected session data", phase: "cleanup", progress: 55 });
+    await assertSelectedSessionsClosed(store.paths, plan.ids);
+    historyLock?.assertHeld();
     mutationStarted = true;
     if (plan.historyMatchCount && await exists(store.paths.historyPath)) {
       const ids = new Set(plan.ids);
-      await rewriteJsonlFile(store.paths.historyPath, (entry) => !entry.parsed || !ids.has(entry.parsed.sessionId ?? entry.parsed.session_id));
+      await rewriteJsonlFile(store.paths.historyPath, (entry) => !entry.parsed || !ids.has(entry.parsed.sessionId ?? entry.parsed.session_id), {
+        beforeCommit: () => historyLock.assertHeld(),
+      });
     }
+    await historyLock?.release();
+    historyLock = null;
     const targets = [...plan.transcriptPaths];
     if (scope === "deep") targets.push(...plan.deepPaths);
     for (const target of [...new Set(targets)].sort((a, b) => b.length - a.length)) await fs.rm(target, { force: true, recursive: true });
@@ -859,9 +988,18 @@ export async function executeSessionDeletion({ onProgress = () => {}, plan, scop
       unrecognizedLocationCount: plan.unrecognizedLocationCount,
     };
   } catch (error) {
-    error.backupDirectory = backupDirectory;
+    error.backupDirectory ??= backupDirectory;
+    backupDirectory = error.backupDirectory;
     error.mutationStarted ??= mutationStarted;
     throw error;
+  } finally {
+    try {
+      await historyLock?.release();
+    } catch (error) {
+      error.backupDirectory = backupDirectory;
+      error.mutationStarted = mutationStarted;
+      throw error;
+    }
   }
 }
 
@@ -869,6 +1007,23 @@ export async function verifySessionDeletion({ plan, scope, store }) {
   const remainingTranscriptPaths = [];
   for (const target of plan.transcriptPaths) if (await exists(target)) remainingTranscriptPaths.push(target);
   if (scope === "deep") for (const target of plan.deepPaths) if (await exists(target)) remainingTranscriptPaths.push(target);
+  // Also catch known sidecars created/recreated after the selection was planned.
+  const sidecarsByDirectory = new Map();
+  for (const record of plan.records) {
+    for (const transcriptPath of record.transcriptPaths) {
+      const directory = path.dirname(transcriptPath);
+      if (!sidecarsByDirectory.has(directory)) {
+        const entries = await fs.readdir(directory, { withFileTypes: true }).catch((error) => {
+          if (error.code === "ENOENT") return [];
+          throw error;
+        });
+        sidecarsByDirectory.set(directory, indexSessionSidecars(directory, entries));
+      }
+      for (const target of sidecarsForTranscript(sidecarsByDirectory.get(directory), transcriptPath, record.id)) {
+        if (!remainingTranscriptPaths.includes(target)) remainingTranscriptPaths.push(target);
+      }
+    }
+  }
   const remainingHistoryEntryCount = (await matchingHistoryStats(store.paths.historyPath, new Set(plan.ids))).count;
   return {
     complete: remainingTranscriptPaths.length === 0 && remainingHistoryEntryCount === 0,
@@ -974,14 +1129,21 @@ export async function restoreSessionDeletionBackup({ backupDirectory, claudeHome
         const id = row.parsed?.sessionId ?? row.parsed?.session_id;
         if (typeof id === "string") selectedIds.add(id);
       }
-      if (await exists(destination)) {
-        const safety = path.join(safetyBackupDirectory, entry.root, entry.relative);
-        await copyTarget(destination, safety);
-        await rewriteJsonlFile(destination, (row) => !row.parsed || !selectedIds.has(row.parsed.sessionId ?? row.parsed.session_id));
-      } else {
-        await fs.mkdir(path.dirname(destination), { recursive: true });
+      await fs.mkdir(path.dirname(destination), { recursive: true });
+      const historyLock = await lockHistory(destination);
+      try {
+        if (await exists(destination)) {
+          const safety = path.join(safetyBackupDirectory, entry.root, entry.relative);
+          await copyTarget(destination, safety);
+          await rewriteJsonlFile(destination, (row) => !row.parsed || !selectedIds.has(row.parsed.sessionId ?? row.parsed.session_id), {
+            beforeCommit: () => historyLock.assertHeld(),
+          });
+        }
+        historyLock.assertHeld();
+        await pipeline(createReadStream(source), createWriteStream(destination, { flags: "a", mode: 0o600 }));
+      } finally {
+        await historyLock.release();
       }
-      await pipeline(createReadStream(source), createWriteStream(destination, { flags: "a", mode: 0o600 }));
     }
     onProgress({ message: "Checking restored sessions", progress: 92 });
     const layoutChanged = manifest.version === 2 && (

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

@@ -8,8 +8,8 @@ const CACHE_TTL_MS = 2_000;
 export const CODEX_DATABASE_PROFILE = Object.freeze({
   id: "codex-local-store-2026-08",
   builtFor: {
-    chatgptDesktop: ["26.727.40816", "26.803.61601", "26.818.21641", "26.818.22352", "26.825.41651"],
-    codexCli: ["0.144.1", "0.146.0", "0.147.0", "0.148.0"],
+    chatgptDesktop: ["26.727.40816", "26.803.61601", "26.818.21641", "26.818.22352", "26.825.41651", "26.903.61454", "26.903.71938"],
+    codexCli: ["0.144.1", "0.146.0", "0.147.0", "0.148.0", "0.153.4", "0.154.0"],
   },
 });
 
@@ -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",