session-steward 0.2.0 → 0.4.0

package/lib/providers/codex/store.mjs

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 
+import { measurePath } from "../../storage/files.mjs";
 import {
   inspectJsonlMatches,
   readJsonlEntries,
@@ -17,6 +18,13 @@ import {
   placeholders,
   queryRows,
 } from "../../storage/sqlite.mjs";
+import {
+  allValidDatabases,
+  CODEX_DATABASE_PROFILE,
+  databaseFamilySummary,
+  invalidateCodexDatabaseResolution,
+  resolveCodexDatabases,
+} from "./database-families.mjs";
 
 function expandHome(value) {
   if (!value || value === "~") {
@@ -42,6 +50,27 @@ function normalizeDisplayName(value) {
   return normalizeText(value);
 }
 
+function cleanDerivedTitle(value) {
+  const original = normalizeDisplayName(value);
+
+  if (!original) {
+    return "";
+  }
+
+  let cleaned = original.replace(/^\[\d+\]\s+(?:user|assistant):\s*/u, "");
+  const nextRoleMarker = cleaned.search(/\s\[\d+\]\s+(?:user|assistant):\s*/u);
+
+  if (nextRoleMarker >= 0) {
+    cleaned = cleaned.slice(0, nextRoleMarker);
+  }
+
+  cleaned = normalizeDisplayName(
+    cleaned.replace(/\[([^\[\]]+?)\]\([^()]*?\)/gu, "$1"),
+  );
+
+  return cleaned && /[\p{L}\p{N}]/u.test(cleaned) ? cleaned : original;
+}
+
 function toTimestampMs(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -368,7 +397,7 @@ function deriveDisplayName({
   if (sessionIndexEntry?.threadName && (!sqliteTitle || sqliteTitleLooksPrompt)) {
     return {
       source: "session_index",
-      value: sessionIndexEntry.threadName,
+      value: cleanDerivedTitle(sessionIndexEntry.threadName),
     };
   }
 
@@ -378,21 +407,21 @@ function deriveDisplayName({
   ) {
     return {
       source: "transcript_thread_name",
-      value: transcriptFallback.latestThreadName,
+      value: cleanDerivedTitle(transcriptFallback.latestThreadName),
     };
   }
 
   if (sqliteTitle) {
     return {
       source: "sqlite_title",
-      value: sqliteTitle,
+      value: cleanDerivedTitle(sqliteTitle),
     };
   }
 
   if (sqliteFirstUserMessage) {
     return {
       source: "sqlite_first_user_message",
-      value: sqliteFirstUserMessage,
+      value: cleanDerivedTitle(sqliteFirstUserMessage),
     };
   }
 
@@ -401,14 +430,14 @@ function deriveDisplayName({
   if (historyEntry?.text) {
     return {
       source: "history_first_user_message",
-      value: historyEntry.text,
+      value: cleanDerivedTitle(historyEntry.text),
     };
   }
 
   if (transcriptFallback?.firstUserMessage) {
     return {
       source: "transcript_first_user_message",
-      value: transcriptFallback.firstUserMessage,
+      value: cleanDerivedTitle(transcriptFallback.firstUserMessage),
     };
   }
 
@@ -418,23 +447,36 @@ function deriveDisplayName({
   };
 }
 
-function getCodexPaths(codexHomeInput) {
+export function getCodexPaths(codexHomeInput, { refresh = false } = {}) {
   const codexHome = path.resolve(expandHome(codexHomeInput || "~/.codex"));
   const archivedSessionsDirectory = path.join(codexHome, "archived_sessions");
   const sessionsDirectory = path.join(codexHome, "sessions");
+  const resolution = resolveCodexDatabases(codexHome, { refresh });
+  const { goals, logs, memories, state } = resolution.families;
+  const stateDatabasePath = state.primary?.path ?? path.join(codexHome, "state_5.sqlite");
+  const logsDatabasePath = logs.primary?.path ?? path.join(codexHome, "logs_2.sqlite");
+  const memoryDatabasePath = memories.primary?.path ?? path.join(codexHome, "memories_1.sqlite");
+  const goalsDatabasePath = goals.primary?.path ?? path.join(codexHome, "goals_1.sqlite");
 
   return {
     archivedSessionsDirectory,
     codexHome,
     desktopStateBackupPath: path.join(codexHome, ".codex-global-state.json.bak"),
     desktopStatePath: path.join(codexHome, ".codex-global-state.json"),
-    goalsDatabasePath: path.join(codexHome, "goals_1.sqlite"),
+    databaseFamilies: resolution.families,
+    goalsDatabasePath,
+    goalsDatabasePaths: allValidDatabases(goals).map((database) => database.path),
     historyPath: path.join(codexHome, "history.jsonl"),
-    logsDatabasePath: path.join(codexHome, "logs_2.sqlite"),
-    memoryDatabasePath: path.join(codexHome, "memories_1.sqlite"),
+    logsDatabasePath,
+    logsDatabasePaths: allValidDatabases(logs).map((database) => database.path),
+    memoryDatabasePath,
+    memoryDatabasePaths: allValidDatabases(memories).map((database) => database.path),
+    resolvedDatabases: databaseFamilySummary(resolution),
     sessionIndexPath: path.join(codexHome, "session_index.jsonl"),
     sessionsDirectory,
-    stateDatabasePath: path.join(codexHome, "state_5.sqlite"),
+    stateDatabasePath,
+    stateDatabases: allValidDatabases(state),
+    stateDatabasePaths: allValidDatabases(state).map((database) => database.path),
     transcriptDirectories: [sessionsDirectory, archivedSessionsDirectory],
   };
 }
@@ -448,27 +490,6 @@ const DESKTOP_THREAD_MAP_KEYS = [
 
 const DESKTOP_THREAD_ARRAY_KEYS = ["projectless-thread-ids"];
 
-const COMPATIBILITY_PROFILE = {
-  id: "local-store-2026-07",
-  builtFor: {
-    chatgptDesktop: ["26.727.40816"],
-    codexCli: ["0.144.1"],
-  },
-};
-
-const SCHEMA_REQUIREMENTS = [
-  {
-    database: "state_5.sqlite",
-    required: true,
-    tables: [
-      { name: "threads", columns: ["id", "rollout_path", "cwd", "title", "first_user_message", "agent_nickname", "agent_role", "archived", "is_pinned"] },
-      { name: "thread_spawn_edges", columns: ["parent_thread_id", "child_thread_id", "status"] },
-    ],
-  },
-  { database: "logs_2.sqlite", required: false, tables: [{ name: "logs", columns: ["thread_id"] }] },
-  { database: "memories_1.sqlite", required: false, tables: [{ name: "stage1_outputs", columns: ["thread_id"] }] },
-  { database: "goals_1.sqlite", required: false, tables: [{ name: "thread_goals", columns: ["thread_id"] }, { name: "thread_goal_continuation_deferrals", columns: ["thread_id"] }] },
-];
 
 function getMatchingDesktopStateEntryCount(state, deletedIdSet) {
   if (!state || typeof state !== "object" || Array.isArray(state)) {
@@ -565,35 +586,22 @@ export async function loadSessionStore({ codexHome }) {
     pathExists(paths.logsDatabasePath),
     pathExists(paths.memoryDatabasePath),
   ]);
-  const threadRows = queryRows(
-    paths.stateDatabasePath,
-    `
-      select
-        id,
-        rollout_path,
-        cwd,
-        title,
-        first_user_message,
-        agent_nickname,
-        agent_role,
-        archived,
-        is_pinned,
-        coalesce(created_at_ms, created_at * 1000) as created_at_ms,
-        coalesce(updated_at_ms, updated_at * 1000) as updated_at_ms
-      from threads
-      order by updated_at_ms desc, updated_at desc
-    `,
-  );
-  const spawnEdges = queryRows(
-    paths.stateDatabasePath,
-    `
-      select
-        parent_thread_id,
-        child_thread_id,
-        status
-      from thread_spawn_edges
-    `,
-  );
+  const threadRowsById = new Map();
+  const spawnEdgesByKey = new Map();
+  for (const database of paths.stateDatabases) {
+    for (const row of queryRows(database.path, `select ${sessionColumns(database)} from threads t`)) {
+      const id = String(row.id);
+      if (!threadRowsById.has(id)) threadRowsById.set(id, { ...row, _stateDatabasePath: database.path });
+    }
+    if (stateSchema(database).hasSpawnEdges) {
+      for (const edge of queryRows(database.path, "select parent_thread_id, child_thread_id, status from thread_spawn_edges")) {
+        const key = `${edge.parent_thread_id}\0${edge.child_thread_id}`;
+        if (!spawnEdgesByKey.has(key)) spawnEdgesByKey.set(key, edge);
+      }
+    }
+  }
+  const threadRows = [...threadRowsById.values()];
+  const spawnEdges = [...spawnEdgesByKey.values()];
   const transcriptHeaders = await indexTranscriptHeaders(paths.transcriptDirectories);
 
   const discoveryIds = new Set(threadRows.map((threadRow) => String(threadRow.id)));
@@ -651,7 +659,7 @@ export async function loadSessionStore({ codexHome }) {
       agentRole: threadRow.agent_role ?? transcriptHeader?.agentRole ?? null,
       archived: Boolean(threadRow.archived),
       childThreadIds: childIdsByParentId.get(threadRow.id) ?? [],
-      createdAtMs: toTimestampMs(threadRow.created_at_ms),
+      createdAtMs: toTimestampMs(threadRow.created_at_ms_resolved ?? threadRow.created_at_ms),
       cwd: threadRow.cwd ?? transcriptHeader?.cwd ?? "",
       displayName: "",
       firstUserMessage: threadRow.first_user_message ?? "",
@@ -669,7 +677,8 @@ export async function loadSessionStore({ codexHome }) {
       rolloutPath,
       title: threadRow.title ?? "",
       titleSource: "",
-      updatedAtMs: toTimestampMs(threadRow.updated_at_ms),
+      updatedAtMs: toTimestampMs(threadRow.updated_at_ms_resolved ?? threadRow.updated_at_ms),
+      _stateDatabasePath: threadRow._stateDatabasePath,
     };
 
     if (
@@ -776,6 +785,12 @@ export async function loadSessionStore({ codexHome }) {
     sessionIndexPath: paths.sessionIndexPath,
     spawnEdges,
     stateDatabasePath: paths.stateDatabasePath,
+    stateDatabasePaths: paths.stateDatabasePaths,
+    stateDatabases: paths.stateDatabases,
+    resolvedDatabases: paths.resolvedDatabases,
+    logsDatabasePaths: paths.logsDatabasePaths,
+    memoryDatabasePaths: paths.memoryDatabasePaths,
+    goalsDatabasePaths: paths.goalsDatabasePaths,
     transcriptHeaders,
     historyPath: paths.historyPath,
   };
@@ -802,51 +817,21 @@ function inspectSqliteTable(databasePath, tableName) {
 }
 
 export async function diagnoseStorageCompatibility({ codexHome }) {
-  const paths = getCodexPaths(codexHome);
-  const recognizedDatabases = new Set(SCHEMA_REQUIREMENTS.map((requirement) => requirement.database));
+  const paths = getCodexPaths(codexHome, { refresh: true });
   const missing = [];
   const changed = [];
   const available = [];
-
-  for (const requirement of SCHEMA_REQUIREMENTS) {
-    const databasePath = path.join(paths.codexHome, requirement.database);
-
-    if (!(await pathExists(databasePath))) {
-      if (requirement.required) {
-        missing.push(`Required session database is missing: ${requirement.database}`);
-      } else {
-        available.push(`Not present: ${requirement.database}`);
-      }
-      continue;
+  for (const [familyName, family] of Object.entries(paths.databaseFamilies)) {
+    if (!family.primary && family.required) {
+      missing.push(`A supported ${familyName} session database was not found.`);
+    } else if (!family.primary) {
+      available.push(`Not present: ${familyName} database`);
     }
-
-    let databaseChanged = false;
-
-    for (const table of requirement.tables) {
-      const inspection = inspectSqliteTable(databasePath, table.name);
-
-      if (inspection.error) {
-        changed.push(`Could not read ${requirement.database}.`);
-        databaseChanged = true;
-        continue;
-      }
-
-      if (!inspection.exists) {
-        changed.push(`Expected table is missing in ${requirement.database}: ${table.name}.`);
-        databaseChanged = true;
-        continue;
-      }
-
-      const missingColumns = table.columns.filter((column) => !inspection.columns.includes(column));
-
-      if (missingColumns.length > 0) {
-        changed.push(`Expected fields changed in ${requirement.database}: ${table.name}.`);
-        databaseChanged = true;
-      }
+    for (const database of allValidDatabases(family)) {
+      available.push(`Supported: ${database.filename}`);
     }
-
-    if (!databaseChanged) {
-      available.push(`Supported: ${requirement.database}`);
+    for (const database of family.invalid) {
+      changed.push(`Could not use ${database.filename}: ${database.reason}`);
     }
   }
 
@@ -857,23 +842,28 @@ export async function diagnoseStorageCompatibility({ codexHome }) {
     missing.push("The local Codex folder could not be read.");
   }
 
+  const recognizedDatabases = new Set(Object.values(paths.databaseFamilies).flatMap((family) => [
+    ...allValidDatabases(family),
+    ...family.invalid,
+  ]).map((database) => database.filename));
   const newlyDiscovered = entries
     .filter((entry) => entry.isFile() && entry.name.endsWith(".sqlite") && !recognizedDatabases.has(entry.name))
     .map((entry) => `Other local database found: ${entry.name}`)
     .sort();
   const status = missing.length > 0 || changed.length > 0
-    ? "update-needed"
+    ? "unsupported"
     : newlyDiscovered.length > 0
-      ? "newer-version"
+      ? "partial"
       : "ready";
 
   return {
     available,
-    builtFor: COMPATIBILITY_PROFILE.builtFor,
+    builtFor: CODEX_DATABASE_PROFILE.builtFor,
     changed,
     missing,
     newlyDiscovered,
-    profileId: COMPATIBILITY_PROFILE.id,
+    profileId: CODEX_DATABASE_PROFILE.id,
+    resolvedDatabases: paths.resolvedDatabases,
     status,
   };
 }
@@ -881,11 +871,7 @@ export async function diagnoseStorageCompatibility({ codexHome }) {
 export async function assertDeepCleanupSupported({ codexHome }) {
   const diagnostic = await diagnoseStorageCompatibility({ codexHome });
 
-  if (diagnostic.status === "newer-version") {
-    throw new Error("Deep cleanup is paused because unrecognized Codex storage was found.");
-  }
-
-  if (diagnostic.status !== "ready") {
+  if (diagnostic.status === "unsupported") {
     throw new Error("Deep cleanup is paused because this Codex storage layout is not supported.");
   }
 
@@ -895,23 +881,181 @@ export async function assertDeepCleanupSupported({ codexHome }) {
 const DEFAULT_PAGE_SIZE = 25;
 const MAX_PAGE_SIZE = 100;
 const OVERVIEW_STAT_BATCH_SIZE = 24;
+const SESSION_SIZE_CACHE_TTL_MS = 45 * 1000;
+const SESSION_SIZE_STAT_CONCURRENCY = 64;
 const SUPPORTING_THREAD_PREFIX = "The following is the Codex agent history whose request action you are assessing";
 const SESSION_CREATED_SQL = "coalesce(nullif(t.created_at_ms, 0), nullif(t.created_at, 0) * 1000, 0)";
 const SESSION_UPDATED_SQL = "coalesce(nullif(t.updated_at_ms, 0), nullif(t.updated_at, 0) * 1000, 0)";
 const SESSION_ACTIVITY_SQL = `coalesce(nullif(${SESSION_UPDATED_SQL}, 0), nullif(${SESSION_CREATED_SQL}, 0), 0)`;
+const SESSION_SORTS = new Set(["created", "cwd", "name", "size", "updated"]);
+const sessionSizeCache = new Map();
+const stateSchemaCache = new WeakMap();
+
+const OPTIONAL_THREAD_COLUMNS = [
+  "agent_nickname", "agent_role", "archived", "cwd", "first_user_message",
+  "is_pinned", "title",
+];
+
+function stateSchema(database) {
+  const known = stateSchemaCache.get(database);
+  if (known) return known;
+  const cached = database.tables?.threads;
+  const columns = cached?.columns?.size
+    ? cached.columns
+    : new Set(inspectSqliteTable(database.path, "threads").columns ?? []);
+  const spawn = database.tables?.thread_spawn_edges?.exists !== undefined
+    ? database.tables.thread_spawn_edges
+    : inspectSqliteTable(database.path, "thread_spawn_edges");
+  const schema = { columns, hasSpawnEdges: Boolean(spawn?.exists) };
+  stateSchemaCache.set(database, schema);
+  return schema;
+}
+
+function columnExpression(columns, column, fallback = "null") {
+  return columns.has(column) ? `t.${column}` : fallback;
+}
+
+function timestampExpression(columns, prefix) {
+  const expressions = [];
+  if (columns.has(`${prefix}_at_ms`)) expressions.push(`nullif(t.${prefix}_at_ms, 0)`);
+  if (columns.has(`${prefix}_at`)) expressions.push(`nullif(t.${prefix}_at, 0) * 1000`);
+  return expressions.length ? `coalesce(${expressions.join(", ")}, 0)` : "0";
+}
+
+function stateExpressions(database) {
+  const schema = stateSchema(database);
+  const created = timestampExpression(schema.columns, "created");
+  const updated = timestampExpression(schema.columns, "updated");
+  return { ...schema, activity: `coalesce(nullif(${updated}, 0), nullif(${created}, 0), 0)`, created, updated };
+}
+
+async function buildSessionSizeIndex(paths) {
+  let rows;
+  if (paths.stateDatabases.length === 1) {
+    rows = queryRows(paths.stateDatabases[0].path, "select id, rollout_path from threads");
+  } else {
+    const rowsById = new Map();
+    for (const database of paths.stateDatabases) {
+      for (const row of queryRows(database.path, "select id, rollout_path from threads")) {
+        const id = String(row.id);
+        if (!rowsById.has(id)) rowsById.set(id, row);
+      }
+    }
+    rows = [...rowsById.values()];
+  }
+  const sizes = new Map();
+  let nextIndex = 0;
 
-function getSessionOrder(sort) {
-  const name = "lower(coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), t.id))";
+  const measureNext = async () => {
+    while (nextIndex < rows.length) {
+      const row = rows[nextIndex];
+      nextIndex += 1;
+      const id = String(row.id);
+
+      if (!row.rollout_path) {
+        sizes.set(id, null);
+        continue;
+      }
+
+      try {
+        const stats = await fs.stat(row.rollout_path);
+        sizes.set(id, stats.isFile() ? stats.size : null);
+      } catch {
+        sizes.set(id, null);
+      }
+    }
+  };
+
+  await Promise.all(
+    Array.from(
+      { length: Math.min(SESSION_SIZE_STAT_CONCURRENCY, rows.length) },
+      measureNext,
+    ),
+  );
+  return sizes;
+}
+
+async function getSessionSizeIndex(paths, { refresh = false } = {}) {
+  const cached = sessionSizeCache.get(paths.codexHome);
+
+  if (!refresh && cached?.expiresAtMs > Date.now()) {
+    return cached.promise;
+  }
+
+  const promise = buildSessionSizeIndex(paths).catch((error) => {
+    if (sessionSizeCache.get(paths.codexHome)?.promise === promise) {
+      sessionSizeCache.delete(paths.codexHome);
+    }
+    throw error;
+  });
+  sessionSizeCache.set(paths.codexHome, {
+    expiresAtMs: Date.now() + SESSION_SIZE_CACHE_TTL_MS,
+    promise,
+  });
+  return promise;
+}
+
+export function invalidateSessionCache({ codexHome }) {
+  const resolvedHome = path.resolve(expandHome(codexHome || "~/.codex"));
+  sessionSizeCache.delete(resolvedHome);
+  invalidateCodexDatabaseResolution(resolvedHome);
+}
+
+function compareSessionIdsBySize(leftId, rightId, sizes) {
+  const leftSize = sizes.get(leftId);
+  const rightSize = sizes.get(rightId);
+  const leftKnown = Number.isFinite(leftSize);
+  const rightKnown = Number.isFinite(rightSize);
+
+  if (leftKnown !== rightKnown) {
+    return leftKnown ? -1 : 1;
+  }
+
+  return (rightSize ?? 0) - (leftSize ?? 0) || leftId.localeCompare(rightId);
+}
+
+function getSessionSort(sort, database) {
+  const { activity, columns, created } = stateExpressions(database);
+  const nameParts = ["t.title", "t.first_user_message"].filter((column) => columns.has(column.slice(2)))
+    .map((column) => `nullif(trim(${column}), '')`);
+  const name = `lower(coalesce(${[...nameParts, "t.id"].join(", ")}))`;
+  const cwd = columns.has("cwd") ? "lower(coalesce(t.cwd, ''))" : "''";
 
   return {
-    created: `${SESSION_CREATED_SQL} desc, t.id asc`,
-    cwd: `lower(coalesce(t.cwd, '')) asc, ${SESSION_ACTIVITY_SQL} desc, t.id asc`,
-    name: `${name} asc, ${SESSION_ACTIVITY_SQL} desc, t.id asc`,
-    updated: `${SESSION_ACTIVITY_SQL} desc, t.id asc`,
-  }[sort] ?? `${SESSION_ACTIVITY_SQL} desc, t.id asc`;
+    created: {
+      compare: (left, right) => Number(right.sort_number) - Number(left.sort_number),
+      order: `${created} desc, t.id asc`,
+      selection: `${created} as sort_number`,
+    },
+    cwd: {
+      compare: (left, right) => String(left.sort_text).localeCompare(String(right.sort_text))
+        || Number(right.sort_activity) - Number(left.sort_activity),
+      order: `${cwd} asc, ${activity} desc, t.id asc`,
+      selection: `${cwd} as sort_text, ${activity} as sort_activity`,
+    },
+    name: {
+      compare: (left, right) => String(left.sort_text).localeCompare(String(right.sort_text))
+        || Number(right.sort_activity) - Number(left.sort_activity),
+      order: `${name} asc, ${activity} desc, t.id asc`,
+      selection: `${name} as sort_text, ${activity} as sort_activity`,
+    },
+    updated: {
+      compare: (left, right) => Number(right.sort_number) - Number(left.sort_number),
+      order: `${activity} desc, t.id asc`,
+      selection: `${activity} as sort_number`,
+    },
+  }[sort] ?? {
+    compare: (left, right) => Number(right.sort_number) - Number(left.sort_number),
+    order: `${activity} desc, t.id asc`,
+    selection: `${activity} as sort_number`,
+  };
+}
+
+function getSessionOrder(sort, database) {
+  return getSessionSort(sort, database).order;
 }
 
-function getSessionConditions({
+function getSessionConditions(database, {
   archiveStatus,
   inactiveBeforeMs,
   includeInternals,
@@ -919,32 +1063,34 @@ function getSessionConditions({
   search,
   workspace,
 }) {
+  const { activity, columns, hasSpawnEdges } = stateExpressions(database);
   const conditions = [];
   const parameters = [];
 
-  if (archiveStatus === "active") {
+  if (archiveStatus === "active" && columns.has("archived")) {
     conditions.push("coalesce(t.archived, 0) = 0");
   } else if (archiveStatus === "archived") {
-    conditions.push("coalesce(t.archived, 0) <> 0");
+    conditions.push(columns.has("archived") ? "coalesce(t.archived, 0) <> 0" : "0 = 1");
   }
 
-  if (!includeInternals) {
+  if (!includeInternals && hasSpawnEdges) {
     conditions.push(`not exists (
       select 1 from thread_spawn_edges edge where edge.child_thread_id = t.id
     )`);
   }
 
-  if (!includeSupporting) {
-    conditions.push("coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), '') not like ?");
+  const supportingColumns = ["title", "first_user_message"].filter((column) => columns.has(column));
+  if (!includeSupporting && supportingColumns.length > 0) {
+    conditions.push(`coalesce(${supportingColumns.map((column) => `nullif(trim(t.${column}), '')`).join(", ")}, '') not like ?`);
     parameters.push(`${SUPPORTING_THREAD_PREFIX}%`);
   }
 
   if (Number.isFinite(inactiveBeforeMs) && inactiveBeforeMs > 0) {
-    conditions.push(`${SESSION_ACTIVITY_SQL} > 0 and ${SESSION_ACTIVITY_SQL} <= ?`);
+    conditions.push(`${activity} > 0 and ${activity} <= ?`);
     parameters.push(Math.trunc(inactiveBeforeMs));
   }
 
-  if (typeof workspace === "string") {
+  if (typeof workspace === "string" && columns.has("cwd")) {
     conditions.push("coalesce(t.cwd, '') = ?");
     parameters.push(workspace);
   }
@@ -952,14 +1098,10 @@ function getSessionConditions({
   const normalizedSearch = normalizeText(search).toLowerCase();
 
   if (normalizedSearch) {
-    conditions.push(`(
-      instr(lower(t.id), ?) > 0
-      or instr(lower(coalesce(t.title, '')), ?) > 0
-      or instr(lower(coalesce(t.first_user_message, '')), ?) > 0
-      or instr(lower(coalesce(t.cwd, '')), ?) > 0
-      or instr(lower(coalesce(t.rollout_path, '')), ?) > 0
-    )`);
-    parameters.push(...Array(5).fill(normalizedSearch));
+    const searchColumns = ["id", "title", "first_user_message", "cwd", "rollout_path"]
+      .filter((column) => column === "id" || columns.has(column));
+    conditions.push(`(${searchColumns.map((column) => `instr(lower(coalesce(t.${column}, '')), ?) > 0`).join(" or ")})`);
+    parameters.push(...Array(searchColumns.length).fill(normalizedSearch));
   }
 
   return {
@@ -968,30 +1110,25 @@ function getSessionConditions({
   };
 }
 
-const SESSION_COLUMNS = `
-  t.id,
-  t.rollout_path,
-  t.cwd,
-  t.title,
-  t.first_user_message,
-  t.agent_nickname,
-  t.agent_role,
-  t.archived,
-  t.is_pinned,
-  ${SESSION_CREATED_SQL} as created_at_ms,
-  ${SESSION_ACTIVITY_SQL} as updated_at_ms,
-  (
-    select edge.parent_thread_id
-    from thread_spawn_edges edge
-    where edge.child_thread_id = t.id
-    limit 1
-  ) as parent_thread_id
-`;
-
-async function formatPagedThreadRows(stateDatabasePath, threadRows) {
+function sessionColumns(database) {
+  const { activity, columns, created, hasSpawnEdges } = stateExpressions(database);
+  const optional = OPTIONAL_THREAD_COLUMNS.map((column) =>
+    `${columnExpression(columns, column)} as ${column}`,
+  );
+  const parent = hasSpawnEdges
+    ? `(select edge.parent_thread_id from thread_spawn_edges edge where edge.child_thread_id = t.id limit 1)`
+    : "null";
+  return `t.id, t.rollout_path, ${optional.join(", ")}, ${created} as created_at_ms_resolved, ${activity} as updated_at_ms_resolved, ${parent} as parent_thread_id`;
+}
+
+async function formatPagedThreadRows(stateDatabase, threadRows) {
+  const stateDatabasePath = typeof stateDatabase === "string" ? stateDatabase : stateDatabase.path;
+  const hasSpawnEdges = typeof stateDatabase === "string"
+    ? inspectSqliteTable(stateDatabasePath, "thread_spawn_edges").exists
+    : stateSchema(stateDatabase).hasSpawnEdges;
   const childIdsByParentId = new Map();
 
-  if (threadRows.length > 0) {
+  if (threadRows.length > 0 && hasSpawnEdges) {
     const ids = threadRows.map((row) => String(row.id));
 
     for (const idBatch of batches(ids)) {
@@ -1014,18 +1151,22 @@ async function formatPagedThreadRows(stateDatabasePath, threadRows) {
   const records = [];
 
   for (const threadRow of threadRows) {
-    const title = normalizeDisplayName(threadRow.title ?? "");
-    const firstUserMessage = getMeaningfulUserText(threadRow.first_user_message ?? "");
+    const title = cleanDerivedTitle(threadRow.title ?? "");
+    const firstUserMessage = cleanDerivedTitle(
+      getMeaningfulUserText(threadRow.first_user_message ?? ""),
+    );
     const displayName = title || firstUserMessage || `Untitled ${String(threadRow.id).slice(0, 8)}`;
     const rolloutPath = threadRow.rollout_path ?? "";
     let transcriptHeader = null;
+    let transcriptBytes = null;
 
     if (rolloutPath) {
-      try {
-        transcriptHeader = await parseTranscriptHeader(rolloutPath);
-      } catch {
-        transcriptHeader = null;
-      }
+      const [header, stats] = await Promise.all([
+        parseTranscriptHeader(rolloutPath).catch(() => null),
+        fs.stat(rolloutPath).catch(() => null),
+      ]);
+      transcriptHeader = header;
+      transcriptBytes = stats?.isFile() ? stats.size : null;
     }
 
     const parentThreadId = threadRow.parent_thread_id ?? transcriptHeader?.parentThreadId ?? null;
@@ -1035,7 +1176,7 @@ async function formatPagedThreadRows(stateDatabasePath, threadRows) {
       agentRole: threadRow.agent_role ?? transcriptHeader?.agentRole ?? null,
       archived: Boolean(threadRow.archived),
       childThreadIds: [...(childIdsByParentId.get(threadRow.id) ?? [])].sort(),
-      createdAtMs: toTimestampMs(threadRow.created_at_ms),
+      createdAtMs: toTimestampMs(threadRow.created_at_ms_resolved ?? threadRow.created_at_ms),
       cwd: threadRow.cwd ?? "",
       displayName,
       firstUserMessage: threadRow.first_user_message ?? "",
@@ -1051,7 +1192,9 @@ async function formatPagedThreadRows(stateDatabasePath, threadRows) {
       rolloutPath,
       title: threadRow.title ?? "",
       titleSource: title ? "sqlite_title" : firstUserMessage ? "sqlite_first_user_message" : "fallback",
-      updatedAtMs: toTimestampMs(threadRow.updated_at_ms),
+      transcriptBytes,
+      updatedAtMs: toTimestampMs(threadRow.updated_at_ms_resolved ?? threadRow.updated_at_ms),
+      _stateDatabasePath: stateDatabasePath,
     });
   }
 
@@ -1068,9 +1211,9 @@ async function getStoreAvailability(paths) {
   ] = await Promise.all([
     pathExists(paths.desktopStatePath),
     pathExists(paths.desktopStateBackupPath),
-    pathExists(paths.goalsDatabasePath),
-    pathExists(paths.logsDatabasePath),
-    pathExists(paths.memoryDatabasePath),
+    Promise.resolve(paths.goalsDatabasePaths.length > 0),
+    Promise.resolve(paths.logsDatabasePaths.length > 0),
+    Promise.resolve(paths.memoryDatabasePaths.length > 0),
   ]);
 
   return {
@@ -1156,13 +1299,13 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
 
   for (let offset = 0; offset < pendingIds.length; offset += 400) {
     const idBatch = pendingIds.slice(offset, offset + 400);
-    const stateChildren = queryRows(
-      paths.stateDatabasePath,
-      `select parent_thread_id, child_thread_id
-       from thread_spawn_edges
-       where parent_thread_id in (${placeholders(idBatch)})`,
-      idBatch,
-    );
+    const stateChildren = paths.stateDatabases.flatMap((database) => stateSchema(database).hasSpawnEdges
+      ? queryRows(
+        database.path,
+        `select parent_thread_id, child_thread_id from thread_spawn_edges where parent_thread_id in (${placeholders(idBatch)})`,
+        idBatch,
+      )
+      : []);
 
     for (const edge of stateChildren) {
       const childId = String(edge.child_thread_id);
@@ -1183,19 +1326,29 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
   }
 
   const ids = [...selectedIds];
-  const threadRows = [];
-
-  for (const idBatch of batches(ids)) {
-    threadRows.push(...queryRows(
-      paths.stateDatabasePath,
-      `select ${SESSION_COLUMNS}
-       from threads t
-       where t.id in (${placeholders(idBatch)})`,
-      idBatch,
-    ));
+  const threadRowsById = new Map();
+  for (const database of paths.stateDatabases) {
+    for (const idBatch of batches(ids)) {
+      for (const row of queryRows(
+        database.path,
+        `select ${sessionColumns(database)} from threads t where t.id in (${placeholders(idBatch)})`,
+        idBatch,
+      )) {
+        const id = String(row.id);
+        if (!threadRowsById.has(id)) threadRowsById.set(id, { ...row, _database: database });
+      }
+    }
   }
-
-  const spawnEdges = queryRelatedSpawnEdges(paths.stateDatabasePath, ids);
+  const threadRows = [...threadRowsById.values()];
+  const spawnEdgesByKey = new Map();
+  for (const database of paths.stateDatabases) {
+    if (!stateSchema(database).hasSpawnEdges) continue;
+    for (const edge of queryRelatedSpawnEdges(database.path, ids)) {
+      const key = `${edge.parent_thread_id}\0${edge.child_thread_id}`;
+      if (!spawnEdgesByKey.has(key)) spawnEdgesByKey.set(key, edge);
+    }
+  }
+  const spawnEdges = [...spawnEdgesByKey.values()];
   const childIdsByParentId = new Map();
   const parentIdsByChildId = new Map();
 
@@ -1220,7 +1373,13 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     }
   }
 
-  const formattedRows = await formatPagedThreadRows(paths.stateDatabasePath, threadRows);
+  const formattedRows = [];
+  for (const database of paths.stateDatabases) {
+    formattedRows.push(...await formatPagedThreadRows(
+      database,
+      threadRows.filter((row) => row._database === database),
+    ));
+  }
   const recordsById = new Map();
 
   for (const record of formattedRows) {
@@ -1322,6 +1481,12 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     sessionIndexPath: paths.sessionIndexPath,
     spawnEdges,
     stateDatabasePath: paths.stateDatabasePath,
+    stateDatabasePaths: paths.stateDatabasePaths,
+    stateDatabases: paths.stateDatabases,
+    resolvedDatabases: paths.resolvedDatabases,
+    logsDatabasePaths: paths.logsDatabasePaths,
+    memoryDatabasePaths: paths.memoryDatabasePaths,
+    goalsDatabasePaths: paths.goalsDatabasePaths,
     transcriptHeaders: new Map(
       [...transcriptHeaders].filter(([id]) => relevantIds.has(id)),
     ),
@@ -1336,46 +1501,113 @@ export async function listSessions({
   includeSupporting = false,
   page = 1,
   pageSize = DEFAULT_PAGE_SIZE,
+  refresh = false,
   search = "",
   sort = "updated",
   workspace,
+  forceUnion = false,
 }) {
-  const paths = getCodexPaths(codexHome);
+  const paths = getCodexPaths(codexHome, { refresh });
   const boundedPageSize = Number.isFinite(pageSize)
     ? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(pageSize)))
     : DEFAULT_PAGE_SIZE;
   const requestedPage = Number.isFinite(page) ? Math.max(1, Math.trunc(page)) : 1;
-  const conditions = getSessionConditions({
-    archiveStatus,
-    inactiveBeforeMs,
-    includeInternals,
-    includeSupporting,
-    search,
-    workspace,
-  });
-  const countRow = queryRows(
-    paths.stateDatabasePath,
-    `select count(*) as count from threads t ${conditions.sql}`,
-    conditions.parameters,
-  )[0];
-  const total = Number(countRow?.count ?? 0);
+  const resolvedSort = SESSION_SORTS.has(sort) ? sort : "updated";
+  if (paths.stateDatabases.length === 1 && resolvedSort !== "size" && !forceUnion) {
+    const database = paths.stateDatabases[0];
+    const conditions = getSessionConditions(database, {
+      archiveStatus, inactiveBeforeMs, includeInternals, includeSupporting, search, workspace,
+    });
+    const countRow = queryRows(
+      database.path,
+      `select count(*) as count from threads t ${conditions.sql}`,
+      conditions.parameters,
+    )[0];
+    const total = Number(countRow?.count ?? 0);
+    const pageCount = Math.max(1, Math.ceil(total / boundedPageSize));
+    const currentPage = Math.min(requestedPage, pageCount);
+    const rows = queryRows(
+      database.path,
+      `select ${sessionColumns(database)}
+       from threads t
+       ${conditions.sql}
+       order by ${getSessionOrder(resolvedSort, database)}
+       limit ? offset ?`,
+      [...conditions.parameters, boundedPageSize, (currentPage - 1) * boundedPageSize],
+    );
+
+    return {
+      page: currentPage,
+      pageCount,
+      pageSize: boundedPageSize,
+      records: await formatPagedThreadRows(database, rows),
+      total,
+    };
+  }
+
+  const ordered = [];
+  const seenIds = paths.stateDatabases.length > 1 ? new Set() : null;
+  const compactSizeIds = resolvedSort === "size" && paths.stateDatabases.length === 1;
+  let compareSortRows = null;
+  for (const database of paths.stateDatabases) {
+    const conditions = getSessionConditions(database, {
+      archiveStatus, inactiveBeforeMs, includeInternals, includeSupporting, search, workspace,
+    });
+    const sessionSort = resolvedSort === "size" ? null : getSessionSort(resolvedSort, database);
+    compareSortRows ??= sessionSort?.compare ?? null;
+    const rows = queryRows(
+      database.path,
+      `select t.id${sessionSort ? `, ${sessionSort.selection}` : ""} from threads t ${conditions.sql}`,
+      conditions.parameters,
+    );
+    for (const row of rows) {
+      const id = String(row.id);
+      if (seenIds?.has(id)) continue;
+      seenIds?.add(id);
+      if (compactSizeIds) {
+        ordered.push(id);
+        continue;
+      }
+      row.database = database;
+      row.id = id;
+      ordered.push(row);
+    }
+  }
+  if (resolvedSort === "size") {
+    const sizes = await getSessionSizeIndex(paths, { refresh });
+    ordered.sort((left, right) => compareSessionIdsBySize(
+      compactSizeIds ? left : left.id,
+      compactSizeIds ? right : right.id,
+      sizes,
+    ));
+  } else {
+    ordered.sort((left, right) => compareSortRows(left, right) || left.id.localeCompare(right.id));
+  }
+  const total = ordered.length;
   const pageCount = Math.max(1, Math.ceil(total / boundedPageSize));
   const currentPage = Math.min(requestedPage, pageCount);
-  const threadRows = queryRows(
-    paths.stateDatabasePath,
-    `select ${SESSION_COLUMNS}
-     from threads t
-     ${conditions.sql}
-     order by ${getSessionOrder(sort)}
-     limit ? offset ?`,
-    [...conditions.parameters, boundedPageSize, (currentPage - 1) * boundedPageSize],
-  );
+  const pageItems = ordered.slice((currentPage - 1) * boundedPageSize, currentPage * boundedPageSize);
+  const recordsById = new Map();
+  const itemsByDatabase = new Map();
+  if (compactSizeIds) {
+    itemsByDatabase.set(paths.stateDatabases[0], pageItems);
+  } else {
+    for (const item of pageItems) {
+      const values = itemsByDatabase.get(item.database) ?? [];
+      values.push(item.id);
+      itemsByDatabase.set(item.database, values);
+    }
+  }
+  for (const [database, ids] of itemsByDatabase) {
+    const rows = queryRows(database.path, `select ${sessionColumns(database)} from threads t where t.id in (${placeholders(ids)})`, ids);
+    for (const record of await formatPagedThreadRows(database, rows)) recordsById.set(record.id, record);
+  }
 
   return {
     page: currentPage,
     pageCount,
     pageSize: boundedPageSize,
-    records: await formatPagedThreadRows(paths.stateDatabasePath, threadRows),
+    records: pageItems.map((item) => recordsById.get(compactSizeIds ? item : item.id)).filter(Boolean),
     total,
   };
 }
@@ -1429,75 +1661,83 @@ async function measureTranscriptStorage(transcriptDirectories) {
   };
 }
 
-export async function getSessionOverview({ codexHome }) {
-  const paths = getCodexPaths(codexHome);
-  const supportingPattern = `${SUPPORTING_THREAD_PREFIX}%`;
-  const overviewRow = queryRows(
-    paths.stateDatabasePath,
-    `select
-       count(*) as total,
-       coalesce(sum(case when coalesce(t.archived, 0) <> 0 then 1 else 0 end), 0) as archived_count,
-       coalesce(sum(case when coalesce(t.archived, 0) = 0 then 1 else 0 end), 0) as active_count,
-       count(children.child_thread_id) as subagent_count,
-       coalesce(sum(case
-         when children.child_thread_id is null
-           and not (coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), '') like ?)
-         then 1
-         else 0
-       end), 0) as primary_session_count,
-       coalesce(sum(case
-         when coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), '') like ? then 1
-         else 0
-       end), 0) as supporting_count,
-       coalesce(sum(case when ${SESSION_ACTIVITY_SQL} = 0 then 1 else 0 end), 0) as unknown_activity_count
-     from threads t
-     left join (
-       select distinct child_thread_id from thread_spawn_edges
-     ) children on children.child_thread_id = t.id`,
-    [supportingPattern, supportingPattern],
-  )[0] ?? {};
-  const workspaceRows = queryRows(
-    paths.stateDatabasePath,
-    `select
-       coalesce(t.cwd, '') as path,
-       count(*) as session_count,
-       max(${SESSION_ACTIVITY_SQL}) as last_activity_at_ms
-     from threads t
-     group by coalesce(t.cwd, '')
-     order by
-       case when coalesce(t.cwd, '') = '' then 1 else 0 end,
-       last_activity_at_ms desc,
-       lower(coalesce(t.cwd, '')) asc`,
-  );
-  const storage = await measureTranscriptStorage(paths.transcriptDirectories);
+export async function getSessionOverview({ codexHome, refresh = false }) {
+  const paths = getCodexPaths(codexHome, { refresh });
+  const sessions = new Map();
+  for (const database of paths.stateDatabases) {
+    const { activity, columns, hasSpawnEdges } = stateExpressions(database);
+    const projection = [
+      "t.id",
+      `${columns.has("cwd") ? "coalesce(t.cwd, '')" : "''"} as path`,
+      `${columns.has("archived") ? "coalesce(t.archived, 0)" : "0"} as archived`,
+      `${columns.has("title") ? "coalesce(t.title, '')" : "''"} as title`,
+      `${columns.has("first_user_message") ? "coalesce(t.first_user_message, '')" : "''"} as first_user_message`,
+      `${activity} as last_activity_at_ms`,
+      `${hasSpawnEdges ? "exists(select 1 from thread_spawn_edges edge where edge.child_thread_id = t.id)" : "0"} as is_subagent`,
+    ].join(", ");
+    for (const row of queryRows(database.path, `select ${projection} from threads t`)) {
+      const id = String(row.id);
+      if (!sessions.has(id)) sessions.set(id, row);
+    }
+  }
+  const workspaceSessionRows = [...sessions.values()];
+  const [sizes, storage] = await Promise.all([
+    getSessionSizeIndex(paths, { refresh }),
+    measureTranscriptStorage(paths.transcriptDirectories),
+  ]);
+  const workspaces = new Map();
+  let archivedSessionCount = 0;
+  let subagentCount = 0;
+  let supportingCount = 0;
+  let unknownActivityCount = 0;
+
+  for (const row of workspaceSessionRows) {
+    const supporting = `${row.title || row.first_user_message || ""}`.startsWith(SUPPORTING_THREAD_PREFIX);
+    archivedSessionCount += row.archived ? 1 : 0;
+    subagentCount += row.is_subagent ? 1 : 0;
+    supportingCount += supporting ? 1 : 0;
+    unknownActivityCount += Number(row.last_activity_at_ms) ? 0 : 1;
+    const workspacePath = row.path ?? "";
+    const current = workspaces.get(workspacePath) ?? {
+      lastActivityAtMs: 0,
+      path: workspacePath,
+      sessionCount: 0,
+      transcriptBytes: 0,
+    };
+    current.lastActivityAtMs = Math.max(
+      current.lastActivityAtMs,
+      toTimestampMs(row.last_activity_at_ms),
+    );
+    current.sessionCount += 1;
+    const transcriptBytes = sizes.get(String(row.id));
+    if (Number.isFinite(transcriptBytes)) current.transcriptBytes += transcriptBytes;
+    workspaces.set(workspacePath, current);
+  }
 
   return {
-    activeSessionCount: Number(overviewRow.active_count ?? 0),
-    archivedSessionCount: Number(overviewRow.archived_count ?? 0),
+    activeSessionCount: sessions.size - archivedSessionCount,
+    archivedSessionCount,
     calculatedAtMs: Date.now(),
-    primarySessionCount: Number(overviewRow.primary_session_count ?? 0),
-    sessionCount: Number(overviewRow.total ?? 0),
-    subagentCount: Number(overviewRow.subagent_count ?? 0),
-    supportingCount: Number(overviewRow.supporting_count ?? 0),
-    unknownActivityCount: Number(overviewRow.unknown_activity_count ?? 0),
-    workspaces: workspaceRows.map((row) => ({
-      lastActivityAtMs: toTimestampMs(row.last_activity_at_ms),
-      path: row.path ?? "",
-      sessionCount: Number(row.session_count ?? 0),
-    })),
+    primarySessionCount: sessions.size - subagentCount - supportingCount,
+    sessionCount: sessions.size,
+    subagentCount,
+    supportingCount,
+    unknownActivityCount,
+    workspaces: [...workspaces.values()].sort((left, right) =>
+      Number(!left.path) - Number(!right.path)
+      || right.lastActivityAtMs - left.lastActivityAtMs
+      || left.path.localeCompare(right.path)),
     ...storage,
   };
 }
 
 export async function getSessionRecord({ codexHome, id }) {
   const paths = getCodexPaths(codexHome);
-  const rows = queryRows(
-    paths.stateDatabasePath,
-    `select ${SESSION_COLUMNS} from threads t where t.id = ? limit 1`,
-    [id],
-  );
-  const records = await formatPagedThreadRows(paths.stateDatabasePath, rows);
-  return records[0] ?? null;
+  for (const database of paths.stateDatabases) {
+    const rows = queryRows(database.path, `select ${sessionColumns(database)} from threads t where t.id = ? limit 1`, [id]);
+    if (rows.length) return (await formatPagedThreadRows(database, rows))[0] ?? null;
+  }
+  return null;
 }
 
 export function filterAndSortSessions({
@@ -1545,6 +1785,12 @@ export function filterAndSortSessions({
     name: (left, right) =>
       left.displayName.localeCompare(right.displayName) ||
       right.updatedAtMs - left.updatedAtMs,
+    size: (left, right) => {
+      const leftKnown = Number.isFinite(left.transcriptBytes);
+      const rightKnown = Number.isFinite(right.transcriptBytes);
+      if (leftKnown !== rightKnown) return leftKnown ? -1 : 1;
+      return (right.transcriptBytes ?? 0) - (left.transcriptBytes ?? 0);
+    },
     updated: (left, right) =>
       right.updatedAtMs - left.updatedAtMs || left.displayName.localeCompare(right.displayName),
   };
@@ -1588,6 +1834,18 @@ function findRowsForIds(databasePath, tableName, columnName, ids, { limitOne = f
   return rows;
 }
 
+function fingerprintRowsForIds(hash, databasePath, tableName, columnName, ids) {
+  for (const idBatch of batches(ids)) {
+    const rows = queryRows(
+      databasePath,
+      `select * from ${tableName} where ${columnName} in (${placeholders(idBatch)})`,
+      idBatch,
+    );
+    rows.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    hash.update(`${databasePath}\0${tableName}\0${JSON.stringify(rows)}\0`);
+  }
+}
+
 function* deleteStatements(tableName, columnName, ids) {
   for (const idBatch of batches(ids)) {
     yield {
@@ -1677,15 +1935,16 @@ export async function planSessionDeletion({ recordIds, store }) {
 
     return count;
   }, 0);
-  const logRowCount = store.hasLogsDatabase
-    ? countRowsForIds(store.logsDatabasePath, "logs", "thread_id", deletionIds)
-    : 0;
-  const memoryRowCount = store.hasMemoryDatabase
-    ? countRowsForIds(store.memoryDatabasePath, "stage1_outputs", "thread_id", deletionIds)
-    : 0;
-  const goalRowCount = store.hasGoalsDatabase
-    ? countRowsForIds(store.goalsDatabasePath, "thread_goals", "thread_id", deletionIds)
-    : 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 goalRowCount = (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean))
+    .reduce((total, databasePath) => total + countRowsForIds(databasePath, "thread_goals", "thread_id", deletionIds), 0);
+  const stateTargets = (store.stateDatabases ?? [{ path: store.stateDatabasePath }]).map((database) => ({
+    database,
+    ids: findRowsForIds(database.path, "threads", "id", deletionIds).map((row) => String(row.id)),
+  }));
 
   return {
     childCount: Math.max(0, deletionIds.length - recordIds.length),
@@ -1704,6 +1963,7 @@ export async function planSessionDeletion({ recordIds, store }) {
     records: selectedRecords,
     sessionIndexMatchCount: sessionIndexMatches.count,
     spawnEdgeCount,
+    stateTargets,
     transcriptBytes,
     transcriptFileCount,
     transcriptPaths,
@@ -1713,19 +1973,19 @@ export async function planSessionDeletion({ recordIds, store }) {
 const BACKUP_MINIMUM_RESERVE_BYTES = 1024 * 1024;
 const BACKUP_RESERVE_RATIO = 0.05;
 
-function getBackupSourcePaths({ plan, store }) {
+function getBackupSourcePaths({ plan, scope, store }) {
   const databasePaths = [
-    store.stateDatabasePath,
-    store.hasLogsDatabase ? store.logsDatabasePath : null,
-    store.hasMemoryDatabase ? store.memoryDatabasePath : null,
-    store.hasGoalsDatabase ? store.goalsDatabasePath : null,
+    ...(store.stateDatabasePaths ?? [store.stateDatabasePath]),
+    ...(store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean)),
+    ...(scope === "deep" ? (store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) : []),
+    ...(scope === "deep" ? (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean)) : []),
   ].filter(Boolean);
 
   return [
     store.historyPath,
     store.sessionIndexPath,
-    store.hasDesktopState ? store.desktopStatePath : null,
-    store.hasDesktopStateBackup ? store.desktopStateBackupPath : null,
+    scope === "deep" && store.hasDesktopState ? store.desktopStatePath : null,
+    scope === "deep" && store.hasDesktopStateBackup ? store.desktopStateBackupPath : null,
     ...plan.transcriptPaths,
     ...databasePaths.flatMap((databasePath) => [
       databasePath,
@@ -1772,6 +2032,7 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
       store.hasMemoryDatabase,
     ] : []),
   ].map(Number).join("\0")}\0`);
+  hash.update(`resolved-databases\0${JSON.stringify(store.resolvedDatabases ?? {})}\0`);
 
   for (const record of [...plan.records].sort((left, right) => left.id.localeCompare(right.id))) {
     hash.update([
@@ -1790,6 +2051,26 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
     hash.update(`id\0${id}\0`);
   }
 
+  for (const database of store.stateDatabases ?? [{ path: store.stateDatabasePath }]) {
+    fingerprintRowsForIds(hash, database.path, "threads", "id", plan.ids);
+    if (stateSchema(database).hasSpawnEdges) {
+      fingerprintRowsForIds(hash, database.path, "thread_spawn_edges", "parent_thread_id", plan.ids);
+      fingerprintRowsForIds(hash, database.path, "thread_spawn_edges", "child_thread_id", plan.ids);
+    }
+  }
+  for (const databasePath of store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean)) {
+    fingerprintRowsForIds(hash, databasePath, "logs", "thread_id", plan.ids);
+  }
+  if (scope === "deep") {
+    for (const databasePath of store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) {
+      fingerprintRowsForIds(hash, databasePath, "stage1_outputs", "thread_id", plan.ids);
+    }
+    for (const databasePath of store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean)) {
+      fingerprintRowsForIds(hash, databasePath, "thread_goals", "thread_id", plan.ids);
+      fingerprintRowsForIds(hash, databasePath, "thread_goal_continuation_deferrals", "thread_id", plan.ids);
+    }
+  }
+
   for (const filePath of [...plan.missingTranscriptPaths].sort()) {
     hash.update(`missing-transcript\0${filePath}\0`);
   }
@@ -1811,9 +2092,9 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
   return hash.digest("hex");
 }
 
-async function estimateBackupBytes({ plan, store }) {
+async function estimateBackupBytes({ plan, scope, store }) {
   let sourceBytes = 0;
-  const uniquePaths = new Set(getBackupSourcePaths({ plan, store }));
+  const uniquePaths = new Set(getBackupSourcePaths({ plan, scope, store }));
 
   for (const sourcePath of uniquePaths) {
     try {
@@ -1869,7 +2150,7 @@ function formatBytes(bytes) {
   return `${value.toFixed(value < 10 ? 1 : 0)} ${unit}`;
 }
 
-export async function preflightSessionDeletion({ availableDiskBytes, plan, store }) {
+export async function preflightSessionDeletion({ availableDiskBytes, plan, scope = "deep", store }) {
   const requiredPaths = [store.stateDatabasePath, store.sessionIndexPath, store.historyPath];
   const missingRequiredPaths = [];
 
@@ -1889,7 +2170,7 @@ export async function preflightSessionDeletion({ availableDiskBytes, plan, store
     store.hasDesktopStateBackup ? readJsonFile(store.desktopStateBackupPath) : null,
   ]);
   const [desktopState, desktopStateBackup] = desktopStates;
-  const backupEstimate = await estimateBackupBytes({ plan, store });
+  const backupEstimate = await estimateBackupBytes({ plan, scope, store });
   const diskCapacityBytes = availableDiskBytes ?? await getAvailableDiskBytes(store.codexHome);
 
   if (diskCapacityBytes < backupEstimate.estimatedBackupBytes) {
@@ -1958,10 +2239,10 @@ async function createOperationBackup({ onProgress, plan, scope, store }) {
     transcriptNameCounts.set(name, (transcriptNameCounts.get(name) ?? 0) + 1);
   }
   const snapshotCandidates = [
-    [store.stateDatabasePath, "state_5.sqlite", true],
-    [store.hasLogsDatabase ? store.logsDatabasePath : null, "logs_2.sqlite", true],
-    [store.hasMemoryDatabase ? store.memoryDatabasePath : null, "memories_1.sqlite", scope === "deep"],
-    [store.hasGoalsDatabase ? store.goalsDatabasePath : null, "goals_1.sqlite", scope === "deep"],
+    ...(store.stateDatabasePaths ?? [store.stateDatabasePath]).map((databasePath) => [databasePath, path.basename(databasePath), true]),
+    ...(store.logsDatabasePaths ?? [store.logsDatabasePath].filter(Boolean)).map((databasePath) => [databasePath, path.basename(databasePath), true]),
+    ...(scope === "deep" ? (store.memoryDatabasePaths ?? [store.memoryDatabasePath].filter(Boolean)) : []).map((databasePath) => [databasePath, path.basename(databasePath), true]),
+    ...(scope === "deep" ? (store.goalsDatabasePaths ?? [store.goalsDatabasePath].filter(Boolean)) : []).map((databasePath) => [databasePath, path.basename(databasePath), true]),
   ];
   const totalItems = backupFiles.length + plan.transcriptPaths.length + snapshotCandidates.length;
   let completedItems = 0;
@@ -2034,7 +2315,18 @@ async function createOperationBackup({ onProgress, plan, scope, store }) {
 
   await atomicWriteFile(
     path.join(backupDirectory, "operation.json"),
-    `${JSON.stringify({ version: 2, ids: plan.ids, scope, createdAtMs: Date.now(), copiedFiles, databaseSnapshots, files }, null, 2)}\n`,
+    `${JSON.stringify({
+      version: 3,
+      ids: plan.ids,
+      scope,
+      createdAtMs: Date.now(),
+      copiedFiles,
+      databaseSnapshots,
+      files,
+      profileId: CODEX_DATABASE_PROFILE.id,
+      resolvedDatabases: store.resolvedDatabases ?? {},
+      compatibilityStatus: (await diagnoseStorageCompatibility({ codexHome: store.codexHome })).status,
+    }, null, 2)}\n`,
   );
 
   return backupDirectory;
@@ -2079,7 +2371,7 @@ export async function executeSessionDeletion({
   });
   if (cancellationRequested(shouldCancel)) throw cleanupCancelled();
   const deletedIdSet = new Set(plan.ids);
-  const preflight = await preflightSessionDeletion({ plan, store });
+  const preflight = await preflightSessionDeletion({ plan, scope, store });
   if (cancellationRequested(shouldCancel)) throw cleanupCancelled();
   const backupDirectory = await createOperationBackup({
     onProgress,
@@ -2101,39 +2393,40 @@ export async function executeSessionDeletion({
 
   try {
     if (scope === "deep" && store.hasMemoryDatabase) {
-      executeTransaction(
-        store.memoryDatabasePath,
-        deleteStatements("stage1_outputs", "thread_id", plan.ids),
-      );
+      for (const databasePath of store.memoryDatabasePaths ?? [store.memoryDatabasePath]) {
+        executeTransaction(databasePath, deleteStatements("stage1_outputs", "thread_id", plan.ids));
+      }
     }
     if (scope === "deep" && store.hasGoalsDatabase) {
-      executeTransaction(
-        store.goalsDatabasePath,
-        deleteStatements("thread_goals", "thread_id", plan.ids),
-      );
+      for (const databasePath of store.goalsDatabasePaths ?? [store.goalsDatabasePath]) {
+        executeTransaction(databasePath, [
+          ...deleteStatements("thread_goal_continuation_deferrals", "thread_id", plan.ids),
+          ...deleteStatements("thread_goals", "thread_id", plan.ids),
+        ]);
+      }
     }
 
     if (store.hasLogsDatabase) {
-      executeTransaction(
-        store.logsDatabasePath,
-        deleteStatements("logs", "thread_id", plan.ids),
-      );
+      for (const databasePath of store.logsDatabasePaths ?? [store.logsDatabasePath]) {
+        executeTransaction(databasePath, deleteStatements("logs", "thread_id", plan.ids));
+      }
     }
-    const stateStatements = [];
-
-    for (const idBatch of batches(plan.ids)) {
-      const idPlaceholders = placeholders(idBatch);
-      stateStatements.push({
-        parameters: [...idBatch, ...idBatch],
-        sql: `delete from thread_spawn_edges where parent_thread_id in (${idPlaceholders}) or child_thread_id in (${idPlaceholders})`,
-      });
-      stateStatements.push({
-        parameters: idBatch,
-        sql: `delete from threads where id in (${idPlaceholders})`,
-      });
+    for (const { database, ids } of plan.stateTargets ?? (store.stateDatabases ?? [{ path: store.stateDatabasePath }]).map((database) => ({ database, ids: plan.ids }))) {
+      const stateStatements = [];
+      const hasSpawnEdges = stateSchema(database).hasSpawnEdges;
+      for (const idBatch of batches(ids)) {
+        const idPlaceholders = placeholders(idBatch);
+        if (hasSpawnEdges) stateStatements.push({
+          parameters: [...idBatch, ...idBatch],
+          sql: `delete from thread_spawn_edges where parent_thread_id in (${idPlaceholders}) or child_thread_id in (${idPlaceholders})`,
+        });
+        stateStatements.push({
+          parameters: idBatch,
+          sql: `delete from threads where id in (${idPlaceholders})`,
+        });
+      }
+      executeTransaction(database.path, stateStatements);
     }
-
-    executeTransaction(store.stateDatabasePath, stateStatements);
     await reportProgress(onProgress, {
       canCancel: false,
       message: "Updating session records",
@@ -2241,6 +2534,55 @@ export async function deleteSessionDeletionBackup({ backupDirectory, codexHome }
   return { backupDirectory: resolvedBackupDirectory };
 }
 
+export async function listSessionDeletionBackups({ codexHome }) {
+  const backupRoot = path.join(path.resolve(codexHome), "session-steward-backups");
+  let entries;
+
+  try {
+    entries = await fs.readdir(backupRoot, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+
+  const backups = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+    const backupDirectory = path.join(backupRoot, entry.name);
+    let operation = null;
+
+    try {
+      operation = await readJsonFile(path.join(backupDirectory, "operation.json"));
+    } catch (error) {
+      if (!(error instanceof SyntaxError)) throw error;
+    }
+
+    const [stats, measured] = await Promise.all([
+      fs.stat(backupDirectory),
+      measurePath(backupDirectory),
+    ]);
+    const restorable = [2, 3].includes(operation?.version) &&
+      Array.isArray(operation.files) &&
+      operation.files.length > 0;
+
+    backups.push({
+      backupDirectory,
+      bytes: measured.bytes,
+      createdAtMs: toTimestampMs(operation?.createdAtMs) || stats.mtimeMs,
+      fileCount: measured.fileCount,
+      id: entry.name,
+      itemCount: Array.isArray(operation?.files) ? operation.files.length : measured.fileCount,
+      providerId: "codex",
+      restorable,
+      scope: operation?.scope === "core" || operation?.scope === "deep" ? operation.scope : null,
+      sessionCount: Array.isArray(operation?.ids) ? operation.ids.length : null,
+    });
+  }
+
+  return backups.sort((left, right) => right.createdAtMs - left.createdAtMs || left.id.localeCompare(right.id));
+}
+
 async function atomicCopyFile(sourcePath, destinationPath) {
   await fs.mkdir(path.dirname(destinationPath), { recursive: true });
   const temporaryPath = `${destinationPath}.session-steward-${process.pid}-${Date.now()}.tmp`;
@@ -2270,9 +2612,10 @@ export async function restoreSessionDeletionBackup({
   const operationPath = path.join(resolvedBackupDirectory, "operation.json");
   const operation = await readJsonFile(operationPath);
 
-  if (operation?.version !== 2 || !Array.isArray(operation.files) || operation.files.length === 0) {
+  if (![2, 3].includes(operation?.version) || !Array.isArray(operation.files) || operation.files.length === 0) {
     throw new Error("This backup cannot be restored automatically. Its files are still available for manual recovery.");
   }
+  const currentDatabasesBeforeRestore = getCodexPaths(codexHome, { refresh: true }).resolvedDatabases;
 
   const files = operation.files.map((entry) => {
     if (typeof entry?.backupPath !== "string" || typeof entry?.originalPath !== "string") {
@@ -2385,7 +2728,10 @@ export async function restoreSessionDeletionBackup({
       progress: 100,
     });
 
+    const layoutChanged = operation.version === 3
+      && JSON.stringify(operation.resolvedDatabases ?? {}) !== JSON.stringify(currentDatabasesBeforeRestore);
     return {
+      note: layoutChanged ? "The Codex storage layout changed after this backup was created. The original files were restored to their recorded locations." : null,
       restoredFileCount: files.length,
       safetyBackupDirectory,
     };
@@ -2401,17 +2747,22 @@ export async function restoreSessionDeletionBackup({
 
 export async function verifySessionDeletion({ plan, scope = "deep", store }) {
   const deletedIdSet = new Set(plan.ids);
-  const remainingThreads = findRowsForIds(
-    store.stateDatabasePath, "threads", "id", plan.ids,
-  );
+  const remainingThreads = (store.stateDatabasePaths ?? [store.stateDatabasePath])
+    .flatMap((databasePath) => findRowsForIds(databasePath, "threads", "id", plan.ids));
   const remainingMemoryRecords = scope === "deep" && store.hasMemoryDatabase
-    ? findRowsForIds(store.memoryDatabasePath, "stage1_outputs", "thread_id", plan.ids)
+    ? (store.memoryDatabasePaths ?? [store.memoryDatabasePath]).flatMap((databasePath) =>
+      findRowsForIds(databasePath, "stage1_outputs", "thread_id", plan.ids))
     : [];
   const remainingGoalRecords = scope === "deep" && store.hasGoalsDatabase
-    ? findRowsForIds(store.goalsDatabasePath, "thread_goals", "thread_id", plan.ids)
+    ? (store.goalsDatabasePaths ?? [store.goalsDatabasePath]).flatMap((databasePath) =>
+      [
+        ...findRowsForIds(databasePath, "thread_goals", "thread_id", plan.ids),
+        ...findRowsForIds(databasePath, "thread_goal_continuation_deferrals", "thread_id", plan.ids),
+      ])
     : [];
   const remainingLogRecords = store.hasLogsDatabase
-    ? findRowsForIds(store.logsDatabasePath, "logs", "thread_id", plan.ids, { limitOne: true })
+    ? (store.logsDatabasePaths ?? [store.logsDatabasePath]).flatMap((databasePath) =>
+      findRowsForIds(databasePath, "logs", "thread_id", plan.ids, { limitOne: true }))
     : [];
   const [sessionIndexMatches, historyMatches] = await Promise.all([
     inspectJsonlMatches(
@@ -2493,6 +2844,7 @@ export function formatSessionForJson(sessionRecord) {
     rolloutMissing: sessionRecord.rolloutMissing,
     rolloutPath: sessionRecord.rolloutPath,
     titleSource: sessionRecord.titleSource,
+    transcriptBytes: sessionRecord.transcriptBytes,
     updatedAtMs: sessionRecord.updatedAtMs,
   };
 }