Apply removal confirmation to archive cleanup

Author: tim-smart

apps/mobile/src/features/home/useThreadListActions.ts

@@ -201,6 +201,7 @@ export function useThreadListActions(): {
           });
           return preview._tag === "Success" ? preview.value.candidate : null;
         },
+        removalPolicy: "confirm",
         confirmRemoval: ({ displayWorktreePath }) =>
           presentWorktreeCleanupConfirmation({
             isIos: process.env.EXPO_OS === "ios",

apps/web/src/components/settings/SettingsPanels.tsx

@@ -1079,7 +1079,7 @@ export function GeneralSettingsPanel() {
 
         <SettingsRow
           title="Worktree remove confirmation"
-          description="Ask before removing a worktree when its last linked thread is deleted."
+          description="Ask before removing a worktree when its last linked thread is archived or deleted."
           resetAction={
             settings.confirmWorktreeRemoval !== DEFAULT_UNIFIED_SETTINGS.confirmWorktreeRemoval ? (
               <SettingResetButton

apps/web/src/hooks/useThreadActions.ts

@@ -241,6 +241,7 @@ export function useThreadActions() {
           });
           return previewResult._tag === "Success" ? previewResult.value.candidate : null;
         },
+        removalPolicy: confirmWorktreeRemoval ? "confirm" : "remove",
         confirmRemoval: localApi
           ? async ({ displayWorktreePath }) => {
               const confirmationResult = await settlePromise(() =>
@@ -326,6 +327,7 @@ export function useThreadActions() {
     [
       archiveThreadMutation,
       cleanupThreadWorktree,
+      confirmWorktreeRemoval,
       getCurrentRouteThreadRef,
       previewWorktreeCleanup,
       resolveThreadTarget,

packages/client-runtime/src/state/worktreeCleanup.test.ts

@@ -15,6 +15,7 @@ const candidate: ArchiveWorktreeCleanupCandidate = {
 
 function makeFlow(overrides?: {
   readonly previewCandidate?: () => Promise<ArchiveWorktreeCleanupCandidate | null>;
+  readonly removalPolicy?: "confirm" | "remove";
   readonly confirmation?: WorktreeCleanupConfirmation<{ readonly _tag: "Failure" }> | null;
   readonly archiveSucceeds?: boolean;
   readonly cleanupOutcome?: WorktreeCleanupOutcome;
@@ -35,6 +36,7 @@ function makeFlow(overrides?: {
   const run = () =>
     runArchiveWithWorktreeCleanup({
       previewCandidate: overrides?.previewCandidate ?? (async () => candidate),
+      removalPolicy: overrides?.removalPolicy ?? "confirm",
       confirmRemoval,
       archive,
       isArchiveSuccess: (result) => result._tag === "Success",
@@ -70,6 +72,17 @@ describe("runArchiveWithWorktreeCleanup", () => {
     expect(flow.cleanup).not.toHaveBeenCalled();
   });
 
+  it("removes the final active worktree without prompting when confirmation is disabled", async () => {
+    const flow = makeFlow({ removalPolicy: "remove", confirmation: null });
+    const outcome = await flow.run();
+    expect(outcome).toEqual({ kind: "archived", result: { _tag: "Success" } });
+    expect(flow.archive).toHaveBeenCalledTimes(1);
+    expect(flow.cleanup).toHaveBeenCalledTimes(1);
+    expect(flow.archive.mock.invocationCallOrder[0]).toBeLessThan(
+      flow.cleanup.mock.invocationCallOrder[0] ?? 0,
+    );
+  });
+
   it("archives without cleanup when the user declines", async () => {
     const flow = makeFlow({ confirmation: { kind: "declined" } });
     const outcome = await flow.run();
@@ -154,6 +167,7 @@ describe("runArchiveWithWorktreeCleanup", () => {
           );
           return shared ? null : target;
         },
+        removalPolicy: "confirm",
         confirmRemoval: async ({ displayWorktreePath }) => {
           prompts.push(displayWorktreePath);
           return { kind: "declined" };

packages/client-runtime/src/state/worktreeCleanup.ts

@@ -2,11 +2,10 @@
  * Shared archive-time worktree cleanup flow.
  *
  * The server owns the safety decision (preview + conditional cleanup RPCs);
- * this module owns the client sequencing shared by web and mobile: prompt
- * only when the server reports a candidate and a confirmation surface
- * exists, archive regardless of the answer, run cleanup only after a
- * confirmed archive, and report cleanup problems without failing the
- * archive itself.
+ * this module owns the client sequencing shared by web and mobile: act only
+ * when the server reports a candidate, optionally confirm based on client
+ * policy, archive before cleanup, and report cleanup problems without
+ * failing the archive itself.
  */
 import type { WorktreeCleanupStatus } from "@t3tools/contracts";
 
@@ -41,10 +40,14 @@ export type ArchiveWithWorktreeCleanupResult<TArchive, TAbort> =
   | { readonly kind: "archived"; readonly result: TArchive }
   | { readonly kind: "aborted"; readonly result: TAbort };
 
+export type WorktreeRemovalPolicy = "confirm" | "remove";
+
 export async function runArchiveWithWorktreeCleanup<TArchive, TAbort = never>(input: {
   /** Server-authoritative preview; null when ineligible or when the preview failed. */
   readonly previewCandidate: () => Promise<ArchiveWorktreeCleanupCandidate | null>;
-  /** Confirmation surface, or null when none is available (no prompt, no cleanup). */
+  /** Whether an eligible worktree is confirmed first or removed automatically. */
+  readonly removalPolicy: WorktreeRemovalPolicy;
+  /** Confirmation surface, or null when none is available. */
   readonly confirmRemoval:
     | ((prompt: {
         readonly candidate: ArchiveWorktreeCleanupCandidate;
@@ -60,13 +63,17 @@ export async function runArchiveWithWorktreeCleanup<TArchive, TAbort = never>(in
   const candidate = await input.previewCandidate();
   let shouldCleanup = false;
   let displayWorktreePath: string | null = null;
-  if (candidate && input.confirmRemoval) {
+  if (candidate) {
     displayWorktreePath = formatWorktreePathForDisplay(candidate.worktreePath);
-    const confirmation = await input.confirmRemoval({ candidate, displayWorktreePath });
-    if (confirmation.kind === "aborted") {
-      return { kind: "aborted", result: confirmation.result };
+    if (input.removalPolicy === "remove") {
+      shouldCleanup = true;
+    } else if (input.confirmRemoval) {
+      const confirmation = await input.confirmRemoval({ candidate, displayWorktreePath });
+      if (confirmation.kind === "aborted") {
+        return { kind: "aborted", result: confirmation.result };
+      }
+      shouldCleanup = confirmation.kind === "confirmed";
     }
-    shouldCleanup = confirmation.kind === "confirmed";
   }
 
   const archiveResult = await input.archive();