session-steward 0.2.0 → 0.3.0

package/lib/providers/codex/index.mjs

@@ -8,6 +8,8 @@ import {
   formatSessionForJson,
   getSessionOverview,
   getSessionRecord,
+  invalidateSessionCache,
+  listSessionDeletionBackups,
   listSessions,
   loadDeletionStore,
   loadSessionStore,
@@ -29,6 +31,8 @@ export const codexProvider = Object.freeze({
   formatSessionForJson,
   getSessionOverview,
   getSessionRecord,
+  invalidateSessionCache,
+  listSessionDeletionBackups,
   listSessions,
   loadDeletionStore,
   loadSessionStore,

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,
@@ -42,6 +43,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 +390,7 @@ function deriveDisplayName({
   if (sessionIndexEntry?.threadName && (!sqliteTitle || sqliteTitleLooksPrompt)) {
     return {
       source: "session_index",
-      value: sessionIndexEntry.threadName,
+      value: cleanDerivedTitle(sessionIndexEntry.threadName),
     };
   }
 
@@ -378,21 +400,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 +423,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),
     };
   }
 
@@ -452,7 +474,7 @@ const COMPATIBILITY_PROFILE = {
   id: "local-store-2026-07",
   builtFor: {
     chatgptDesktop: ["26.727.40816"],
-    codexCli: ["0.144.1"],
+    codexCli: ["0.144.1", "0.146.0"],
   },
 };
 
@@ -895,10 +917,88 @@ 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();
+
+async function buildSessionSizeIndex(paths) {
+  const rows = queryRows(
+    paths.stateDatabasePath,
+    "select id, rollout_path from threads",
+  );
+  const sizes = new Map();
+  let nextIndex = 0;
+
+  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 }) {
+  sessionSizeCache.delete(getCodexPaths(codexHome).codexHome);
+}
+
+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 getSessionOrder(sort) {
   const name = "lower(coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), t.id))";
@@ -1014,18 +1114,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;
@@ -1051,6 +1155,7 @@ async function formatPagedThreadRows(stateDatabasePath, threadRows) {
       rolloutPath,
       title: threadRow.title ?? "",
       titleSource: title ? "sqlite_title" : firstUserMessage ? "sqlite_first_user_message" : "fallback",
+      transcriptBytes,
       updatedAtMs: toTimestampMs(threadRow.updated_at_ms),
     });
   }
@@ -1336,6 +1441,7 @@ export async function listSessions({
   includeSupporting = false,
   page = 1,
   pageSize = DEFAULT_PAGE_SIZE,
+  refresh = false,
   search = "",
   sort = "updated",
   workspace,
@@ -1345,6 +1451,7 @@ export async function listSessions({
     ? 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 resolvedSort = SESSION_SORTS.has(sort) ? sort : "updated";
   const conditions = getSessionConditions({
     archiveStatus,
     inactiveBeforeMs,
@@ -1353,6 +1460,42 @@ export async function listSessions({
     search,
     workspace,
   });
+  if (resolvedSort === "size") {
+    const sizes = await getSessionSizeIndex(paths, { refresh });
+    const matchingIds = queryRows(
+      paths.stateDatabasePath,
+      `select t.id from threads t ${conditions.sql}`,
+      conditions.parameters,
+    ).map((row) => String(row.id));
+    matchingIds.sort((left, right) => compareSessionIdsBySize(left, right, sizes));
+    const total = matchingIds.length;
+    const pageCount = Math.max(1, Math.ceil(total / boundedPageSize));
+    const currentPage = Math.min(requestedPage, pageCount);
+    const pageIds = matchingIds.slice(
+      (currentPage - 1) * boundedPageSize,
+      currentPage * boundedPageSize,
+    );
+    const threadRows = pageIds.length > 0
+      ? queryRows(
+        paths.stateDatabasePath,
+        `select ${SESSION_COLUMNS}
+         from threads t
+         where t.id in (${placeholders(pageIds)})`,
+        pageIds,
+      )
+      : [];
+    const rowsById = new Map(threadRows.map((row) => [String(row.id), row]));
+    const orderedRows = pageIds.map((id) => rowsById.get(id)).filter(Boolean);
+
+    return {
+      page: currentPage,
+      pageCount,
+      pageSize: boundedPageSize,
+      records: await formatPagedThreadRows(paths.stateDatabasePath, orderedRows),
+      total,
+    };
+  }
+
   const countRow = queryRows(
     paths.stateDatabasePath,
     `select count(*) as count from threads t ${conditions.sql}`,
@@ -1366,7 +1509,7 @@ export async function listSessions({
     `select ${SESSION_COLUMNS}
      from threads t
      ${conditions.sql}
-     order by ${getSessionOrder(sort)}
+     order by ${getSessionOrder(resolvedSort)}
      limit ? offset ?`,
     [...conditions.parameters, boundedPageSize, (currentPage - 1) * boundedPageSize],
   );
@@ -1429,7 +1572,7 @@ async function measureTranscriptStorage(transcriptDirectories) {
   };
 }
 
-export async function getSessionOverview({ codexHome }) {
+export async function getSessionOverview({ codexHome, refresh = false }) {
   const paths = getCodexPaths(codexHome);
   const supportingPattern = `${SUPPORTING_THREAD_PREFIX}%`;
   const overviewRow = queryRows(
@@ -1456,20 +1599,37 @@ export async function getSessionOverview({ codexHome }) {
      ) children on children.child_thread_id = t.id`,
     [supportingPattern, supportingPattern],
   )[0] ?? {};
-  const workspaceRows = queryRows(
+  const workspaceSessionRows = queryRows(
     paths.stateDatabasePath,
     `select
+       t.id,
        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`,
+       ${SESSION_ACTIVITY_SQL} as last_activity_at_ms
+     from threads t`,
   );
-  const storage = await measureTranscriptStorage(paths.transcriptDirectories);
+  const [sizes, storage] = await Promise.all([
+    getSessionSizeIndex(paths, { refresh }),
+    measureTranscriptStorage(paths.transcriptDirectories),
+  ]);
+  const workspaces = new Map();
+
+  for (const row of workspaceSessionRows) {
+    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),
@@ -1480,11 +1640,10 @@ export async function getSessionOverview({ codexHome }) {
     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),
-    })),
+    workspaces: [...workspaces.values()].sort((left, right) =>
+      Number(!left.path) - Number(!right.path)
+      || right.lastActivityAtMs - left.lastActivityAtMs
+      || left.path.localeCompare(right.path)),
     ...storage,
   };
 }
@@ -1545,6 +1704,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),
   };
@@ -1713,19 +1878,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,
+    scope === "deep" && store.hasMemoryDatabase ? store.memoryDatabasePath : null,
+    scope === "deep" && store.hasGoalsDatabase ? store.goalsDatabasePath : null,
   ].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,
@@ -1811,9 +1976,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 +2034,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 +2054,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) {
@@ -2079,7 +2244,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,
@@ -2241,6 +2406,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 = operation?.version === 2 &&
+      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`;
@@ -2493,6 +2707,7 @@ export function formatSessionForJson(sessionRecord) {
     rolloutMissing: sessionRecord.rolloutMissing,
     rolloutPath: sessionRecord.rolloutPath,
     titleSource: sessionRecord.titleSource,
+    transcriptBytes: sessionRecord.transcriptBytes,
     updatedAtMs: sessionRecord.updatedAtMs,
   };
 }

package/lib/providers/index.mjs

@@ -1,6 +1,7 @@
 import { codexProvider } from "./codex/index.mjs";
+import { claudeCodeProvider } from "./claude-code/index.mjs";
 
-const providers = Object.freeze([codexProvider]);
+const providers = Object.freeze([codexProvider, claudeCodeProvider]);
 const providersById = new Map(providers.map((provider) => [provider.id, provider]));
 
 export function getProvider(providerId) {