session-steward 0.10.3 → 0.11.1

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,