session-steward 0.10.2 → 0.11.0

package/lib/providers/codex/store.mjs

@@ -27,6 +27,12 @@ import {
   resolveCodexDatabases,
 } from "./database-families.mjs";
 import { expandHomePath } from "../../platform.mjs";
+import {
+  deleteDesktopCatalogs,
+  readDesktopCatalogs,
+  restoreDesktopCatalogs,
+  validateDesktopCatalogBackup,
+} from "./desktop-catalog.mjs";
 
 function normalizeText(value) {
   if (typeof value !== "string") {
@@ -1616,6 +1622,7 @@ export async function listSessions({
   sort = "updated",
   workspace,
   forceUnion = false,
+  recordFilter = null,
 }) {
   const paths = getCodexPaths(codexHome, { refresh });
   const boundedPageSize = Number.isFinite(pageSize)
@@ -1628,7 +1635,7 @@ export async function listSessions({
     ? Math.trunc(minimumTranscriptBytes)
     : null;
   const needsSizeIndex = resolvedSort === "size" || resolvedMinimumTranscriptBytes !== null;
-  if (paths.stateDatabases.length === 1 && !needsSizeIndex && !forceUnion) {
+  if (paths.stateDatabases.length === 1 && !needsSizeIndex && !forceUnion && typeof recordFilter !== "function") {
     const database = paths.stateDatabases[0];
     const conditions = getSessionConditions(database, {
       archiveStatus, inactiveBeforeMs, includeInternals, includeSupporting, search, workspace,
@@ -1662,7 +1669,7 @@ export async function listSessions({
 
   const ordered = [];
   const seenIds = paths.stateDatabases.length > 1 ? new Set() : null;
-  const compactSizeIds = resolvedSort === "size" && paths.stateDatabases.length === 1;
+  const compactSizeIds = resolvedSort === "size" && paths.stateDatabases.length === 1 && typeof recordFilter !== "function";
   const sizes = needsSizeIndex ? await getSessionSizeIndex(paths, { refresh }) : null;
   let compareSortRows = null;
   for (const database of paths.stateDatabases) {
@@ -1670,16 +1677,22 @@ export async function listSessions({
       archiveStatus, inactiveBeforeMs, includeInternals, includeSupporting, search, workspace,
     });
     const sessionSort = resolvedSort === "size" ? null : getSessionSort(resolvedSort, database);
+    const filterSelection = typeof recordFilter === "function"
+      ? `, ${stateSchema(database).columns.has("cwd") ? "coalesce(t.cwd, '')" : "''"} as filter_cwd`
+      : "";
     compareSortRows ??= sessionSort?.compare ?? null;
     const rows = queryRows(
       database.path,
-      `select t.id${sessionSort ? `, ${sessionSort.selection}` : ""} from threads t ${conditions.sql}`,
+      `select t.id${sessionSort ? `, ${sessionSort.selection}` : ""}${filterSelection} 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 (typeof recordFilter === "function" && !recordFilter({ cwd: String(row.filter_cwd || ""), id })) {
+        continue;
+      }
       if (resolvedMinimumTranscriptBytes !== null) {
         const transcriptBytes = sizes.get(id);
         if (!Number.isFinite(transcriptBytes) || transcriptBytes < resolvedMinimumTranscriptBytes) {
@@ -2349,6 +2362,7 @@ async function getPathFingerprint(filePath) {
 export async function fingerprintSessionDeletion({ plan, scope, store }) {
   const hash = createHash("sha256");
   hash.update(`${store.codexHome}\0${scope}\0`);
+  hash.update(`desktop-catalogs\0${JSON.stringify(readDesktopCatalogs(store.codexHome, plan.ids))}\0`);
 
   const counts = [
     plan.dynamicToolRowCount,
@@ -2467,7 +2481,7 @@ export async function fingerprintSessionDeletion({ plan, scope, store }) {
 }
 
 async function estimateBackupBytes({ plan, scope, store }) {
-  let sourceBytes = 0;
+  let sourceBytes = Buffer.byteLength(JSON.stringify(readDesktopCatalogs(store.codexHome, plan.ids), null, 2));
   const uniquePaths = new Set(getBackupSourcePaths({ plan, scope, store }));
 
   for (const sourcePath of uniquePaths) {
@@ -2685,6 +2699,8 @@ function formatBytes(bytes) {
 }
 
 export async function preflightSessionDeletion({ availableDiskBytes, plan, scope = "deep", store }) {
+  // Fail on an unknown app catalogue before backing up or mutating sessions.
+  readDesktopCatalogs(store.codexHome, plan.ids);
   const requiredPaths = [store.stateDatabasePath, store.sessionIndexPath, store.historyPath];
   const missingRequiredPaths = [];
 
@@ -2865,6 +2881,7 @@ async function createOperationBackup({ onProgress, plan, scope, store }) {
       files,
       profileId: CODEX_DATABASE_PROFILE.id,
       resolvedDatabases: store.resolvedDatabases ?? {},
+      desktopCatalogs: readDesktopCatalogs(store.codexHome, plan.ids),
       compatibilityStatus: (await diagnoseStorageCompatibility({ codexHome: store.codexHome })).status,
     }, null, 2)}\n`,
   );
@@ -2941,6 +2958,8 @@ export async function executeSessionDeletion({
   });
 
   try {
+    const operation = await readJsonFile(path.join(backupDirectory, "operation.json"));
+    deleteDesktopCatalogs(store.codexHome, plan.ids, operation.desktopCatalogs);
     if (scope === "deep" && store.hasMemoryDatabase) {
       for (const databasePath of store.memoryDatabasePaths ?? [store.memoryDatabasePath]) {
         executeTransaction(
@@ -3188,6 +3207,8 @@ export async function restoreSessionDeletionBackup({
     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 desktopCatalogs = operation.desktopCatalogs ?? [];
+  validateDesktopCatalogBackup(codexHome, operation.ids ?? [], desktopCatalogs);
 
   const files = operation.files.map((entry) => {
     if (typeof entry?.backupPath !== "string" || typeof entry?.originalPath !== "string") {
@@ -3293,6 +3314,8 @@ export async function restoreSessionDeletionBackup({
       }
     }
 
+    restoreDesktopCatalogs(codexHome, operation.ids ?? [], desktopCatalogs);
+
     await reportProgress(onProgress, {
       canCancel: false,
       message: "Restore completed",
@@ -3318,6 +3341,8 @@ export async function restoreSessionDeletionBackup({
 }
 
 export async function verifySessionDeletion({ plan, scope = "deep", store }) {
+  const remainingDesktopCatalogEntries = readDesktopCatalogs(store.codexHome, plan.ids)
+    .flatMap((entry) => entry.rows.map((row) => ({ filename: entry.filename, id: row.thread_id })));
   const deletedIdSet = new Set(plan.ids);
   const remainingThreads = (store.stateDatabasePaths ?? [store.stateDatabasePath])
     .flatMap((databasePath) => findRowsForIds(databasePath, "threads", "id", plan.ids));
@@ -3418,7 +3443,9 @@ export async function verifySessionDeletion({ plan, scope = "deep", store }) {
       sessionIndexMatches.count === 0 &&
       historyMatches.count === 0 &&
       remainingTranscriptPaths.length === 0 &&
+      remainingDesktopCatalogEntries.length === 0 &&
       remainingDesktopStateReferences.length === 0,
+    remainingDesktopCatalogEntries,
     remainingDesktopStateReferences,
     remainingDynamicTools,
     remainingGoalRecords,

package/lib/server.mjs

@@ -11,6 +11,7 @@ import {
   MAX_SESSION_EVENT_LIMIT,
 } from "./session-event-reader.mjs";
 import { createProviderSettings } from "./settings.mjs";
+import { createSessionProtectionStore } from "./session-protections.mjs";
 import { classifyInstalledVersion } from "./version-support.mjs";
 import {
   acquireSessionMutationLock,
@@ -349,6 +350,9 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
       ...(claudeHome === undefined ? {} : { "claude-code": claudeHome }),
     },
   });
+  const protectionStore = createSessionProtectionStore({
+    configDirectory: settings.getConfigDirectory(),
+  });
   const mutationToken = randomBytes(32).toString("base64url");
   let mutationInProgress = false;
   let activeOperationId = null;
@@ -463,6 +467,7 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
         expectedFingerprint: savedPlan.fingerprint,
         onProgress: (update) => Object.assign(operation, update),
         options,
+        protectionStore,
         provider,
         recordIds: savedPlan.requestedIds,
         scope: savedPlan.scope,
@@ -758,9 +763,20 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
       if (request.method === "GET" && requestUrl.pathname === "/api/sessions") {
         const providerId = resolveProviderId(requestUrl.searchParams.get("provider"));
         const provider = getProvider(providerId);
+        const home = settings.getHome(providerId);
+        const protectionSnapshot = await protectionStore.list();
+        const protectionMatcher = protectionStore.matcher({
+          providerHome: home,
+          providerId,
+          snapshot: protectionSnapshot,
+        });
+        const keepFilter = requestUrl.searchParams.get("keep");
+        if (keepFilter && keepFilter !== "kept") {
+          throw new Error("Keep filter must be kept.");
+        }
         const result = await provider.listSessions({
           archiveStatus: getArchiveStatus(requestUrl.searchParams.get("archiveStatus")),
-          ...providerOptions(providerId, settings.getHome(providerId)),
+          ...providerOptions(providerId, home),
           inactiveBeforeMs: getInactiveBeforeMs(requestUrl.searchParams.get("inactiveDays")),
           includeInternals: requestUrl.searchParams.get("includeInternals") === "true",
           includeSupporting: requestUrl.searchParams.get("includeSupporting") === "true",
@@ -772,10 +788,16 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
           workspace: requestUrl.searchParams.has("workspace")
             ? requestUrl.searchParams.get("workspace")
             : undefined,
+          recordFilter: keepFilter === "kept"
+            ? (record) => protectionMatcher(record).kept
+            : null,
         });
         sendJson(response, 200, {
           ...result,
-          records: result.records.map(provider.formatSessionForJson),
+          records: result.records.map((record) => ({
+            ...provider.formatSessionForJson(record),
+            keep: protectionMatcher(record),
+          })),
         });
         return;
       }
@@ -852,7 +874,67 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
           return;
         }
 
-        sendJson(response, 200, { record: provider.formatSessionForJson(record) });
+        const protectionSnapshot = await protectionStore.list();
+        sendJson(response, 200, {
+          record: {
+            ...provider.formatSessionForJson(record),
+            keep: protectionStore.classify({
+              providerHome: settings.getHome(providerId),
+              providerId,
+              record,
+              snapshot: protectionSnapshot,
+            }),
+          },
+        });
+        return;
+      }
+
+      if (request.method === "GET" && requestUrl.pathname === "/api/protections") {
+        const providerId = resolveProviderId(requestUrl.searchParams.get("provider"));
+        const kind = requestUrl.searchParams.get("kind") || "workspaces";
+        if (kind !== "workspaces") throw new Error("Keep rule kind must be workspaces.");
+        const result = await protectionStore.listWorkspaceRules({
+          page: getPositiveInteger(requestUrl.searchParams.get("page"), 1),
+          pageSize: getPositiveInteger(requestUrl.searchParams.get("pageSize"), 25, 100),
+          search: requestUrl.searchParams.get("search"),
+        });
+        sendJson(response, 200, { ...result, providerId });
+        return;
+      }
+
+      if (["PUT", "DELETE"].includes(request.method) && requestUrl.pathname === "/api/protections") {
+        requireMutationAuthorization({ request, requestUrl, token: mutationToken });
+        if (activeOperationId) {
+          sendJson(response, 409, { error: "Wait for the current cleanup to finish before changing Keep." });
+          return;
+        }
+        const body = await readJsonBody(request);
+        if (body.kind === "session") {
+          const providerId = resolveProviderId(body.providerId);
+          const input = {
+            providerHome: settings.getHome(providerId),
+            providerId,
+            sessionId: getSessionId(body.sessionId),
+          };
+          if (request.method === "PUT") await protectionStore.keepSession(input);
+          else await protectionStore.removeSession(input);
+        } else if (body.kind === "sessions") {
+          const providerId = resolveProviderId(body.providerId);
+          const input = {
+            providerHome: settings.getHome(providerId),
+            providerId,
+            sessionIds: normalizeIds(body.sessionIds).map(getSessionId),
+          };
+          if (request.method === "PUT") await protectionStore.keepSessions(input);
+          else await protectionStore.removeSessions(input);
+        } else if (body.kind === "workspace") {
+          if (request.method === "PUT") await protectionStore.keepWorkspace({ workspace: body.workspace });
+          else await protectionStore.removeWorkspace({ workspace: body.workspace });
+        } else {
+          throw new Error("Keep kind must be session, sessions, or workspace.");
+        }
+        deletionPlans.clear();
+        sendJson(response, 200, { updated: true });
         return;
       }
 
@@ -867,12 +949,13 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
 
         const prepared = await prepareSessionCleanup({
           options,
+          protectionStore,
           provider,
           recordIds: ids,
           scope,
         });
         const { plan, preflight } = prepared;
-        const id = randomBytes(18).toString("base64url");
+        const id = plan.ids.length > 0 ? randomBytes(18).toString("base64url") : null;
         const expiresAtMs = Date.now() + PLAN_TTL_MS;
         const savedPlan = {
           home,
@@ -888,7 +971,7 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
         while (deletionPlans.size >= MAX_SAVED_PLANS) {
           deletionPlans.delete(deletionPlans.keys().next().value);
         }
-        deletionPlans.set(id, savedPlan);
+        if (id) deletionPlans.set(id, savedPlan);
         const warnings = [];
         if (preflight.activeThreadDetection === "unavailable") {
           warnings.push(`The current ${provider.displayName} runtime cannot identify an active session. Confirm it is safe to delete the selected sessions.`);
@@ -901,6 +984,8 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
             ...summarizePlan(plan, preflight, scope),
             expiresAtMs,
             id,
+            skippedProtectionCount: prepared.skippedProtections.length,
+            skippedProtections: prepared.skippedProtections,
             warnings,
           },
           scope,

package/lib/session-cleanup.mjs

@@ -142,6 +142,124 @@ function validateScope(scope) {
   return scope;
 }
 
+function emptyDeletionPlan(plan) {
+  return {
+    ...plan,
+    childCount: 0,
+    deepFiles: [],
+    deepPaths: [],
+    desktopStateMatchCount: 0,
+    dynamicToolRowCount: 0,
+    goalRowCount: 0,
+    historyMatchBytes: 0,
+    historyMatchCount: 0,
+    ids: [],
+    logRowCount: 0,
+    memoryJobRowCount: 0,
+    memoryOutputRowCount: 0,
+    memoryRowCount: 0,
+    memoryConsolidations: [],
+    missingTranscriptPaths: [],
+    newestLinkedActivityAtMs: 0,
+    queueRevisionRowCount: 0,
+    queueRowCount: 0,
+    records: [],
+    sessionIndexMatchCount: 0,
+    spawnEdgeCount: 0,
+    stateTargets: [],
+    threadHistoryRowCount: 0,
+    transcriptBytes: 0,
+    transcriptFileCount: 0,
+    transcriptPaths: [],
+  };
+}
+
+function emptyPreflight() {
+  return {
+    desktopStateMatchCount: 0,
+    estimatedBackupBytes: 0,
+    transcriptBytes: 0,
+    transcriptFileCount: 0,
+  };
+}
+
+async function applySessionProtections({ options, plan, protectionStore, provider, recordIds, store }) {
+  if (!protectionStore) {
+    return { plan, protectionRevision: null, skippedProtections: [] };
+  }
+  const snapshot = await protectionStore.list();
+  const home = providerHome({ options, provider });
+  const classifications = new Map(plan.records.map((record) => [
+    record.id,
+    protectionStore.classify({ providerHome: home, providerId: provider.id, record, snapshot }),
+  ]));
+  const requested = new Set(recordIds);
+  const skippedById = new Map();
+
+  for (const id of recordIds) {
+    const protection = classifications.get(id);
+    if (protection?.kept) {
+      skippedById.set(id, { id, keep: protection, reason: "kept-session" });
+    }
+  }
+
+  const recordsById = new Map(plan.records.map((record) => [record.id, record]));
+  for (const [protectedId, protection] of classifications) {
+    if (!protection.kept || requested.has(protectedId)) continue;
+    let current = recordsById.get(protectedId);
+    const visited = new Set();
+    let assignedToRequestedRoot = false;
+    while (current?.parentThreadId && !visited.has(current.id)) {
+      visited.add(current.id);
+      const parentId = current.parentThreadId;
+      if (requested.has(parentId)) {
+        if (!skippedById.has(parentId)) {
+          skippedById.set(parentId, {
+            id: parentId,
+            keep: protection,
+            linkedSessionId: protectedId,
+            reason: "kept-linked-session",
+          });
+        }
+        assignedToRequestedRoot = true;
+        break;
+      }
+      current = recordsById.get(parentId);
+    }
+    if (!assignedToRequestedRoot) {
+      throw cleanupReviewError("A linked session is marked Keep. Review the selection again before cleanup.");
+    }
+  }
+
+  const effectiveIds = recordIds.filter((id) => !skippedById.has(id));
+  if (effectiveIds.length === recordIds.length) {
+    return { plan, protectionRevision: snapshot.revision, skippedProtections: [] };
+  }
+  if (effectiveIds.length === 0) {
+    return {
+      plan: emptyDeletionPlan(plan),
+      protectionRevision: snapshot.revision,
+      skippedProtections: [...skippedById.values()],
+    };
+  }
+  const effectivePlan = await provider.planSessionDeletion({ recordIds: effectiveIds, store });
+  for (const record of effectivePlan.records) {
+    if (protectionStore.classify({
+      providerHome: home,
+      providerId: provider.id,
+      record,
+      snapshot,
+    }).kept) {
+      throw cleanupReviewError("A linked session is marked Keep. Review the selection again before cleanup.");
+    }
+  }
+  return {
+    plan: effectivePlan,
+    protectionRevision: snapshot.revision,
+    skippedProtections: [...skippedById.values()],
+  };
+}
+
 export async function resolveSessionCleanupScope({ options, provider, scope }) {
   const requestedScope = validateScope(scope);
   if (requestedScope !== "deep") {
@@ -172,7 +290,7 @@ function summarizeVerification(verification) {
   };
 }
 
-async function loadCurrentCleanup({ expectedFingerprint, options, provider, recordIds, scope }) {
+async function loadCurrentCleanup({ expectedFingerprint, options, protectionStore, provider, recordIds, scope }) {
   if (scope === "deep") await provider.assertDeepCleanupSupported(options);
 
   let store;
@@ -185,21 +303,45 @@ async function loadCurrentCleanup({ expectedFingerprint, options, provider, reco
     throw error;
   }
 
-  const plan = await provider.planSessionDeletion({ recordIds, store });
-  const fingerprint = await provider.fingerprintSessionDeletion({ plan, scope, store });
+  const requestedPlan = await provider.planSessionDeletion({ recordIds, store });
+  const protectedPlan = await applySessionProtections({
+    options,
+    plan: requestedPlan,
+    protectionStore,
+    provider,
+    recordIds,
+    store,
+  });
+  const plan = protectedPlan.plan;
+  const providerFingerprint = plan.ids.length > 0
+    ? await provider.fingerprintSessionDeletion({ plan, scope, store })
+    : "no-unprotected-sessions";
+  const fingerprint = JSON.stringify({
+    protectionRevision: protectedPlan.protectionRevision,
+    providerFingerprint,
+  });
   if (expectedFingerprint !== undefined && fingerprint !== expectedFingerprint) {
     throw cleanupReviewError("Session data changed after this preview. Review the selection again.");
   }
 
-  const preflight = await provider.preflightSessionDeletion({ plan, scope, store });
-  return { fingerprint, plan, preflight, store };
+  const preflight = plan.ids.length > 0
+    ? await provider.preflightSessionDeletion({ plan, scope, store })
+    : emptyPreflight();
+  return {
+    fingerprint,
+    plan,
+    preflight,
+    skippedProtections: protectedPlan.skippedProtections,
+    store,
+  };
 }
 
-export async function prepareSessionCleanup({ options, provider, recordIds, scope }) {
+export async function prepareSessionCleanup({ options, protectionStore, provider, recordIds, scope }) {
   const requestedIds = normalizeRecordIds(recordIds);
   const resolvedScope = validateScope(scope);
   const current = await loadCurrentCleanup({
     options,
+    protectionStore,
     provider,
     recordIds: requestedIds,
     scope: resolvedScope,
@@ -209,14 +351,16 @@ export async function prepareSessionCleanup({ options, provider, recordIds, scop
     plan: current.plan,
     preflight: current.preflight,
     requestedIds,
+    skippedProtections: current.skippedProtections,
     scope: resolvedScope,
   };
 }
 
-export async function revalidateSessionCleanup({ expectedFingerprint, options, provider, recordIds, scope }) {
+export async function revalidateSessionCleanup({ expectedFingerprint, options, protectionStore, provider, recordIds, scope }) {
   return loadCurrentCleanup({
     expectedFingerprint,
     options,
+    protectionStore,
     provider,
     recordIds: normalizeRecordIds(recordIds),
     scope: validateScope(scope),
@@ -227,59 +371,76 @@ export async function executePreparedSessionCleanup({
   expectedFingerprint,
   onProgress = () => {},
   options,
+  protectionStore,
   provider,
   recordIds,
   scope,
   shouldCancel = () => false,
 }) {
-  const current = await revalidateSessionCleanup({
-    expectedFingerprint,
-    options,
-    provider,
-    recordIds,
-    scope,
-  });
-  let deletion;
+  const releaseProtectionLease = await protectionStore?.acquireLease();
   try {
-    deletion = await provider.executeSessionDeletion({
-      onProgress,
-      plan: current.plan,
+    const current = await revalidateSessionCleanup({
+      expectedFingerprint,
+      options,
+      protectionStore,
+      provider,
+      recordIds,
       scope,
-      shouldCancel,
-      store: current.store,
     });
-  } catch (error) {
-    if (error && typeof error === "object") error.cleanupPlan ??= current.plan;
-    throw error;
-  }
-  onProgress({
-    canCancel: false,
-    message: "Checking that cleanup completed",
-    phase: "verification",
-    progress: 94,
-  });
-  let verification;
-  try {
-    verification = await provider.verifySessionDeletion({
-      plan: current.plan,
-      scope,
-      store: current.store,
+    if (current.plan.ids.length === 0) {
+      return {
+        deletion: null,
+        plan: current.plan,
+        preflight: current.preflight,
+        skippedProtections: current.skippedProtections,
+        verification: null,
+      };
+    }
+    let deletion;
+    try {
+      deletion = await provider.executeSessionDeletion({
+        onProgress,
+        plan: current.plan,
+        scope,
+        shouldCancel,
+        store: current.store,
+      });
+    } catch (error) {
+      if (error && typeof error === "object") error.cleanupPlan ??= current.plan;
+      throw error;
+    }
+    onProgress({
+      canCancel: false,
+      message: "Checking that cleanup completed",
+      phase: "verification",
+      progress: 94,
     });
-  } catch (error) {
-    if (error && typeof error === "object") {
-      error.backupDirectory ??= deletion.backupDirectory;
-      error.cleanupPlan ??= current.plan;
-      error.deletionResult ??= deletion;
-      error.mutationStarted ??= true;
+    let verification;
+    try {
+      verification = await provider.verifySessionDeletion({
+        plan: current.plan,
+        scope,
+        store: current.store,
+      });
+    } catch (error) {
+      if (error && typeof error === "object") {
+        error.backupDirectory ??= deletion.backupDirectory;
+        error.cleanupPlan ??= current.plan;
+        error.deletionResult ??= deletion;
+        error.mutationStarted ??= true;
+      }
+      throw error;
     }
-    throw error;
+    return {
+      deletion,
+      plan: current.plan,
+      preflight: current.preflight,
+      skippedProtections: current.skippedProtections,
+      verification,
+    };
+  } finally {
+    await releaseProtectionLease?.();
   }
-  return {
-    deletion,
-    plan: current.plan,
-    preflight: current.preflight,
-    verification,
-  };
 }
 
 async function deleteBackups(provider, options, backupDirectories) {
@@ -327,12 +488,14 @@ async function restoreAndCheck({ backupDirectory, options, plan, provider, onPro
   }
 }
 
-function baseResult({ plan, preflight, requestedIds, scope }) {
+function baseResult({ plan, preflight, requestedIds, scope, skippedProtections = [] }) {
   return {
     affectedSessionCount: plan.ids.length,
-    childSessionCount: Math.max(0, plan.ids.length - requestedIds.length),
+    childSessionCount: plan.childCount ?? Math.max(0, plan.ids.length - requestedIds.length),
     cleanupMode: scope === "deep" ? "thorough" : "standard",
     requestedSessionCount: requestedIds.length,
+    skippedProtectionCount: skippedProtections.length,
+    skippedProtections,
     transcriptBytes: preflight.transcriptBytes ?? plan.transcriptBytes ?? 0,
     transcriptFileCount: preflight.transcriptFileCount ?? plan.transcriptFileCount ?? 0,
   };
@@ -350,10 +513,10 @@ function safeCleanupError(error, backupRetained) {
   );
 }
 
-async function runSessionCleanupUnlocked({ onProgress, options, provider, recordIds, scope, signal }) {
+async function runSessionCleanupUnlocked({ onProgress, options, protectionStore, provider, recordIds, scope, signal }) {
   let prepared;
   try {
-    prepared = await prepareSessionCleanup({ options, provider, recordIds, scope });
+    prepared = await prepareSessionCleanup({ options, protectionStore, provider, recordIds, scope });
   } catch (error) {
     if (error?.code === SESSION_CLEANUP_REVIEW_REQUIRED) {
       throw cleanupReviewError("The selected session data changed before cleanup. Find matching sessions again and retry.");
@@ -365,7 +528,20 @@ async function runSessionCleanupUnlocked({ onProgress, options, provider, record
     preflight: prepared.preflight,
     requestedIds: prepared.requestedIds,
     scope: prepared.scope,
+    skippedProtections: prepared.skippedProtections,
   });
+  if (prepared.plan.ids.length === 0) {
+    return {
+      ...base,
+      deletedSessionCount: 0,
+      deletedTranscriptCount: 0,
+      recovery: { attempted: false, backupRetained: false, completed: false },
+      skippedTranscriptCount: 0,
+      status: "protected",
+      unrecognizedLocationCount: 0,
+      verification: null,
+    };
+  }
   let backupDirectory = null;
   let deletionResult = null;
   let execution = null;
@@ -375,6 +551,7 @@ async function runSessionCleanupUnlocked({ onProgress, options, provider, record
       expectedFingerprint: prepared.fingerprint,
       onProgress,
       options,
+      protectionStore,
       provider,
       recordIds: prepared.requestedIds,
       scope: prepared.scope,