feat(storage): clean up settled thread worktrees (#15208)

Co-authored-by: maria-rcks <maria@kuuro.net>

Author: Bil0000

apps/server/src/environment/ServerEnvironment.test.ts

@@ -118,6 +118,13 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
         expect(descriptor.capabilities.serverSelfUpdate).toBe(
           mode === "web" ? undefined : "desktop-managed",
         );
+        expect(descriptor.capabilities).toMatchObject({
+          settledWorktreeCleanup: true,
+          storageCleanupRun: true,
+          projectWorktreeCleanup: true,
+          worktreesDirectory: true,
+          threadAutoSettlementScope: true,
+        });
       }
     }),
   );

apps/server/src/environment/ServerEnvironment.ts

@@ -231,6 +231,7 @@ export const make = Effect.gen(function* () {
       storageCleanupRun: true,
       otlpEndpointCheck: true,
       projectWorktreeCleanup: true,
+      settledWorktreeCleanup: true,
       worktreesDirectory: true,
       threadAutoSettlementScope: true,
       threadRestartContinuation: true,

apps/server/src/orchestration-v2/CheckpointRestoreSafety.test.ts

@@ -16,7 +16,9 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
+import * as GitWorkflowService from "../git/GitWorkflowService.ts";
 import * as CheckpointRollbackService from "./CheckpointRollbackService.ts";
+import { isCheckpointRestoreIsolated } from "./CheckpointRestoreSafety.ts";
 import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
 import { CheckpointServiceV2 } from "./CheckpointService.ts";
 import { EventSinkV2 } from "./EventSink.ts";
@@ -105,6 +107,7 @@ it.effect.each([
           NodeServices.layer,
           ThreadCommandExecutor.layer,
           IdAllocator.layer,
+          Layer.mock(GitWorkflowService.GitWorkflowService)({}),
           Layer.mock(ProjectStore.ProjectStoreV2)({
             get: () => Effect.succeed(Option.some({ workspaceRoot: parent } as never)),
           }),
@@ -197,3 +200,25 @@ it.effect.each([
     }
   }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
 );
+
+it.effect("lets rollback recreate a worktree storage cleanup removed", () =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const parent = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-v2-restore-removed-" });
+    const worktreePath = path.join(parent, "worktree");
+    const isolated = yield* isCheckpointRestoreIsolated(
+      { id: ThreadId.make("restore-removed"), worktreePath },
+      { cwd: worktreePath },
+      {
+        fileSystem,
+        path,
+        projections: {
+          getShellSnapshot: () => Effect.succeed({ threads: [], archivedThreads: [] }),
+        } as never,
+        projects: {} as never,
+      },
+    );
+    assert.isTrue(isolated);
+  }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);

apps/server/src/orchestration-v2/CheckpointRestoreSafety.ts

@@ -33,8 +33,19 @@ export const isCheckpointRestoreIsolated = Effect.fn("orchestrationV2.isCheckpoi
     const worktreePath = thread.worktreePath;
     let shared = worktreePath == null;
     if (!shared && worktreePath !== null) {
-      const cwd = yield* fileSystem.realPath(scope.cwd);
-      const worktreeCwd = yield* fileSystem.realPath(worktreePath);
+      // Storage cleanup may have removed the worktree; rollback recreates it.
+      const resolve = (target: string) =>
+        fileSystem
+          .realPath(target)
+          .pipe(
+            Effect.catch((error) =>
+              error.reason._tag === "NotFound"
+                ? Effect.succeed(path.resolve(target))
+                : Effect.fail(error),
+            ),
+          );
+      const cwd = yield* resolve(scope.cwd);
+      const worktreeCwd = yield* resolve(worktreePath);
       shared = cwd !== worktreeCwd;
       if (!shared) {
         const shell = yield* projections.getShellSnapshot();