session-steward 0.1.1 → 0.3.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,
@@ -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;
@@ -139,6 +161,12 @@ async function pathExists(targetPath) {
   }
 }
 
+function isContainedPath(rootDirectory, candidatePath) {
+  if (!candidatePath) return false;
+  const relativePath = path.relative(path.resolve(rootDirectory), path.resolve(candidatePath));
+  return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+
 async function readFirstLine(filePath) {
   const stream = createReadStream(filePath, {
     encoding: "utf8",
@@ -362,7 +390,7 @@ function deriveDisplayName({
   if (sessionIndexEntry?.threadName && (!sqliteTitle || sqliteTitleLooksPrompt)) {
     return {
       source: "session_index",
-      value: sessionIndexEntry.threadName,
+      value: cleanDerivedTitle(sessionIndexEntry.threadName),
     };
   }
 
@@ -372,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),
     };
   }
 
@@ -395,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),
     };
   }
 
@@ -414,8 +442,11 @@ function deriveDisplayName({
 
 function getCodexPaths(codexHomeInput) {
   const codexHome = path.resolve(expandHome(codexHomeInput || "~/.codex"));
+  const archivedSessionsDirectory = path.join(codexHome, "archived_sessions");
+  const sessionsDirectory = path.join(codexHome, "sessions");
 
   return {
+    archivedSessionsDirectory,
     codexHome,
     desktopStateBackupPath: path.join(codexHome, ".codex-global-state.json.bak"),
     desktopStatePath: path.join(codexHome, ".codex-global-state.json"),
@@ -424,8 +455,9 @@ function getCodexPaths(codexHomeInput) {
     logsDatabasePath: path.join(codexHome, "logs_2.sqlite"),
     memoryDatabasePath: path.join(codexHome, "memories_1.sqlite"),
     sessionIndexPath: path.join(codexHome, "session_index.jsonl"),
-    sessionsDirectory: path.join(codexHome, "sessions"),
+    sessionsDirectory,
     stateDatabasePath: path.join(codexHome, "state_5.sqlite"),
+    transcriptDirectories: [sessionsDirectory, archivedSessionsDirectory],
   };
 }
 
@@ -442,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"],
   },
 };
 
@@ -584,21 +616,7 @@ export async function loadSessionStore({ codexHome }) {
       from thread_spawn_edges
     `,
   );
-  const transcriptHeaders = new Map();
-
-  for await (const transcriptFile of findTranscriptFiles(paths.sessionsDirectory)) {
-    try {
-      const header = await parseTranscriptHeader(transcriptFile);
-
-      const current = header?.id ? transcriptHeaders.get(header.id) : null;
-
-      if (header?.id && (!current || header.filePath > current.filePath)) {
-        transcriptHeaders.set(header.id, header);
-      }
-    } catch {
-      continue;
-    }
-  }
+  const transcriptHeaders = await indexTranscriptHeaders(paths.transcriptDirectories);
 
   const discoveryIds = new Set(threadRows.map((threadRow) => String(threadRow.id)));
 
@@ -698,7 +716,7 @@ export async function loadSessionStore({ codexHome }) {
     const record = {
       agentNickname: transcriptHeader.agentNickname,
       agentRole: transcriptHeader.agentRole,
-      archived: false,
+      archived: isContainedPath(paths.archivedSessionsDirectory, transcriptHeader.filePath),
       childThreadIds: childIdsByParentId.get(transcriptId) ?? [],
       createdAtMs: transcriptHeader.timestampMs,
       cwd: transcriptHeader.cwd,
@@ -898,25 +916,118 @@ 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 updated = "coalesce(t.updated_at_ms, t.updated_at * 1000, 0)";
-  const created = "coalesce(t.created_at_ms, t.created_at * 1000, 0)";
   const name = "lower(coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), t.id))";
 
   return {
-    created: `${created} desc, t.id asc`,
-    cwd: `lower(coalesce(t.cwd, '')) asc, ${updated} desc, t.id asc`,
-    name: `${name} asc, ${updated} desc, t.id asc`,
-    updated: `${updated} desc, t.id asc`,
-  }[sort] ?? `${updated} desc, t.id asc`;
+    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`;
 }
 
-function getSessionConditions({ includeInternals, includeSupporting, search }) {
+function getSessionConditions({
+  archiveStatus,
+  inactiveBeforeMs,
+  includeInternals,
+  includeSupporting,
+  search,
+  workspace,
+}) {
   const conditions = [];
   const parameters = [];
 
+  if (archiveStatus === "active") {
+    conditions.push("coalesce(t.archived, 0) = 0");
+  } else if (archiveStatus === "archived") {
+    conditions.push("coalesce(t.archived, 0) <> 0");
+  }
+
   if (!includeInternals) {
     conditions.push(`not exists (
       select 1 from thread_spawn_edges edge where edge.child_thread_id = t.id
@@ -928,6 +1039,16 @@ function getSessionConditions({ includeInternals, includeSupporting, search }) {
     parameters.push(`${SUPPORTING_THREAD_PREFIX}%`);
   }
 
+  if (Number.isFinite(inactiveBeforeMs) && inactiveBeforeMs > 0) {
+    conditions.push(`${SESSION_ACTIVITY_SQL} > 0 and ${SESSION_ACTIVITY_SQL} <= ?`);
+    parameters.push(Math.trunc(inactiveBeforeMs));
+  }
+
+  if (typeof workspace === "string") {
+    conditions.push("coalesce(t.cwd, '') = ?");
+    parameters.push(workspace);
+  }
+
   const normalizedSearch = normalizeText(search).toLowerCase();
 
   if (normalizedSearch) {
@@ -957,8 +1078,8 @@ const SESSION_COLUMNS = `
   t.agent_role,
   t.archived,
   t.is_pinned,
-  coalesce(t.created_at_ms, t.created_at * 1000, 0) as created_at_ms,
-  coalesce(t.updated_at_ms, t.updated_at * 1000, 0) as updated_at_ms,
+  ${SESSION_CREATED_SQL} as created_at_ms,
+  ${SESSION_ACTIVITY_SQL} as updated_at_ms,
   (
     select edge.parent_thread_id
     from thread_spawn_edges edge
@@ -993,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;
@@ -1030,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),
     });
   }
@@ -1061,19 +1187,21 @@ async function getStoreAvailability(paths) {
   };
 }
 
-async function indexTranscriptHeaders(sessionsDirectory) {
+async function indexTranscriptHeaders(transcriptDirectories) {
   const headersById = new Map();
 
-  for await (const transcriptFile of findTranscriptFiles(sessionsDirectory)) {
-    try {
-      const header = await parseTranscriptHeader(transcriptFile);
-      const current = header?.id ? headersById.get(String(header.id)) : null;
+  for (const transcriptDirectory of transcriptDirectories) {
+    for await (const transcriptFile of findTranscriptFiles(transcriptDirectory)) {
+      try {
+        const header = await parseTranscriptHeader(transcriptFile);
+        const current = header?.id ? headersById.get(String(header.id)) : null;
 
-      if (header?.id && (!current || header.filePath > current.filePath)) {
-        headersById.set(String(header.id), { ...header, id: String(header.id) });
+        if (header?.id && (!current || header.filePath > current.filePath)) {
+          headersById.set(String(header.id), { ...header, id: String(header.id) });
+        }
+      } catch {
+        continue;
       }
-    } catch {
-      continue;
     }
   }
 
@@ -1126,7 +1254,7 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
 
   const [availability, transcriptHeaders] = await Promise.all([
     getStoreAvailability(paths),
-    indexTranscriptHeaders(paths.sessionsDirectory),
+    indexTranscriptHeaders(paths.transcriptDirectories),
   ]);
   const transcriptChildrenByParentId = getTranscriptChildrenByParentId(transcriptHeaders);
   const pendingIds = [...selectedIds];
@@ -1218,7 +1346,7 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     recordsById.set(id, {
       agentNickname: header.agentNickname,
       agentRole: header.agentRole,
-      archived: false,
+      archived: isContainedPath(paths.archivedSessionsDirectory, header.filePath),
       childThreadIds: [...(childIdsByParentId.get(id) ?? [])].sort(),
       createdAtMs: header.timestampMs,
       cwd: header.cwd,
@@ -1306,20 +1434,68 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
 }
 
 export async function listSessions({
+  archiveStatus = "all",
   codexHome,
+  inactiveBeforeMs = null,
   includeInternals = false,
   includeSupporting = false,
   page = 1,
   pageSize = DEFAULT_PAGE_SIZE,
+  refresh = false,
   search = "",
   sort = "updated",
+  workspace,
 }) {
   const paths = getCodexPaths(codexHome);
   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({ includeInternals, includeSupporting, search });
+  const resolvedSort = SESSION_SORTS.has(sort) ? sort : "updated";
+  const conditions = getSessionConditions({
+    archiveStatus,
+    inactiveBeforeMs,
+    includeInternals,
+    includeSupporting,
+    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}`,
@@ -1333,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],
   );
@@ -1347,6 +1523,131 @@ export async function listSessions({
   };
 }
 
+async function measureTranscriptStorage(transcriptDirectories) {
+  let transcriptBytes = 0;
+  let transcriptFileCount = 0;
+  let unreadableFileCount = 0;
+  let pendingPaths = [];
+
+  const measurePendingPaths = async () => {
+    const pathsToMeasure = pendingPaths;
+    pendingPaths = [];
+    const results = await Promise.all(pathsToMeasure.map(async (filePath) => {
+      try {
+        return await fs.stat(filePath);
+      } catch {
+        return null;
+      }
+    }));
+
+    for (const stats of results) {
+      if (!stats?.isFile()) {
+        unreadableFileCount += 1;
+        continue;
+      }
+
+      transcriptBytes += stats.size;
+      transcriptFileCount += 1;
+    }
+  };
+
+  for (const transcriptDirectory of transcriptDirectories) {
+    for await (const transcriptPath of findTranscriptFiles(transcriptDirectory)) {
+      pendingPaths.push(transcriptPath);
+
+      if (pendingPaths.length >= OVERVIEW_STAT_BATCH_SIZE) {
+        await measurePendingPaths();
+      }
+    }
+  }
+
+  if (pendingPaths.length > 0) {
+    await measurePendingPaths();
+  }
+
+  return {
+    transcriptBytes,
+    transcriptFileCount,
+    unreadableFileCount,
+  };
+}
+
+export async function getSessionOverview({ codexHome, refresh = false }) {
+  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 workspaceSessionRows = queryRows(
+    paths.stateDatabasePath,
+    `select
+       t.id,
+       coalesce(t.cwd, '') as path,
+       ${SESSION_ACTIVITY_SQL} as last_activity_at_ms
+     from threads t`,
+  );
+  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),
+    archivedSessionCount: Number(overviewRow.archived_count ?? 0),
+    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: [...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(
@@ -1359,6 +1660,7 @@ export async function getSessionRecord({ codexHome, id }) {
 }
 
 export function filterAndSortSessions({
+  archiveStatus = "all",
   includeInternals,
   records,
   search,
@@ -1366,6 +1668,14 @@ export function filterAndSortSessions({
 }) {
   const normalizedSearch = normalizeText(search).toLowerCase();
   const filteredRecords = records.filter((record) => {
+    if (archiveStatus === "active" && record.archived) {
+      return false;
+    }
+
+    if (archiveStatus === "archived" && !record.archived) {
+      return false;
+    }
+
     if (!includeInternals && record.isSubagent) {
       return false;
     }
@@ -1394,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),
   };
@@ -1477,6 +1793,33 @@ export async function planSessionDeletion({ recordIds, store }) {
     .map((record) => record.rolloutPath)
     .filter(Boolean);
   const deletionIdSet = new Set(deletionIds);
+  const requestedIdSet = new Set(recordIds);
+  const newestLinkedActivityAtMs = selectedRecords.reduce((newest, record) => {
+    if (requestedIdSet.has(record.id)) {
+      return newest;
+    }
+
+    return Math.max(newest, record.updatedAtMs ?? 0);
+  }, 0);
+  let transcriptBytes = 0;
+  let transcriptFileCount = 0;
+
+  for (const transcriptBatch of batches([...new Set(transcriptPaths)], OVERVIEW_STAT_BATCH_SIZE)) {
+    const results = await Promise.all(transcriptBatch.map(async (transcriptPath) => {
+      try {
+        return await fs.stat(transcriptPath);
+      } catch (error) {
+        if (error?.code === "ENOENT") return null;
+        throw error;
+      }
+    }));
+
+    for (const stats of results) {
+      if (!stats?.isFile()) continue;
+      transcriptBytes += stats.size;
+      transcriptFileCount += 1;
+    }
+  }
   const [historyMatches, sessionIndexMatches] = await Promise.all([
     inspectJsonlMatches(
       store.historyPath,
@@ -1522,9 +1865,12 @@ export async function planSessionDeletion({ recordIds, store }) {
     logRowCount,
     memoryRowCount,
     missingTranscriptPaths,
+    newestLinkedActivityAtMs,
     records: selectedRecords,
     sessionIndexMatchCount: sessionIndexMatches.count,
     spawnEdgeCount,
+    transcriptBytes,
+    transcriptFileCount,
     transcriptPaths,
   };
 }
@@ -1532,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,
@@ -1630,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 {
@@ -1688,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 = [];
 
@@ -1708,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) {
@@ -1898,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,
@@ -2043,6 +2389,72 @@ function resolveContainedPath(rootDirectory, candidatePath) {
   return resolved;
 }
 
+export async function deleteSessionDeletionBackup({ backupDirectory, codexHome }) {
+  const backupRoot = path.join(codexHome, "session-steward-backups");
+  const resolvedBackupDirectory = resolveContainedPath(backupRoot, backupDirectory);
+
+  if (resolvedBackupDirectory === path.resolve(backupRoot)) {
+    throw new Error("Choose one recovery backup to delete.");
+  }
+
+  await fs.rm(resolvedBackupDirectory, {
+    force: true,
+    maxRetries: 3,
+    recursive: true,
+    retryDelay: 25,
+  });
+  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`;
@@ -2295,6 +2707,7 @@ export function formatSessionForJson(sessionRecord) {
     rolloutMissing: sessionRecord.rolloutMissing,
     rolloutPath: sessionRecord.rolloutPath,
     titleSource: sessionRecord.titleSource,
+    transcriptBytes: sessionRecord.transcriptBytes,
     updatedAtMs: sessionRecord.updatedAtMs,
   };
 }