Clear stale worktree paths before starting sessions (#135)

- Fall back to the project workspace when a saved worktree no longer exists
- Reset stale thread worktree metadata before launching provider sessions
- Add coverage for stale worktree recovery

Author: BunsDev

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -1,3 +1,4 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -95,13 +96,16 @@ describe("ProviderCommandReactor", () => {
   async function createHarness(input?: {
     readonly baseDir?: string;
     readonly threadModel?: string;
+    readonly worktreePath?: string | null;
   }) {
     const now = new Date().toISOString();
     const baseDir = input?.baseDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "okcode-reactor-"));
     createdBaseDirs.add(baseDir);
     const { stateDir } = deriveServerPathsSync(baseDir, undefined);
     createdStateDirs.add(stateDir);
     const threadModel = input?.threadModel ?? "gpt-5-codex";
+    const projectWorkspaceRoot = path.join(baseDir, "project");
+    fs.mkdirSync(projectWorkspaceRoot, { recursive: true });
     const runtimeEventPubSub = Effect.runSync(PubSub.unbounded<ProviderRuntimeEvent>());
     let nextSessionIndex = 1;
     const runtimeSessions: Array<ProviderSession> = [];
@@ -244,7 +248,7 @@ describe("ProviderCommandReactor", () => {
         commandId: CommandId.makeUnsafe("cmd-project-create"),
         projectId: asProjectId("project-1"),
         title: "Provider Project",
-        workspaceRoot: "/tmp/provider-project",
+        workspaceRoot: projectWorkspaceRoot,
         defaultModel: threadModel,
         createdAt: now,
       }),
@@ -260,7 +264,7 @@ describe("ProviderCommandReactor", () => {
         interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
         runtimeMode: "approval-required",
         branch: null,
-        worktreePath: null,
+        worktreePath: input?.worktreePath ?? null,
         createdAt: now,
       }),
     );
@@ -275,6 +279,7 @@ describe("ProviderCommandReactor", () => {
       stopSession,
       renameBranch,
       generateBranchName,
+      projectWorkspaceRoot,
       stateDir,
       drain,
     };
@@ -305,7 +310,7 @@ describe("ProviderCommandReactor", () => {
     await waitFor(() => harness.sendTurn.mock.calls.length === 1);
     expect(harness.startSession.mock.calls[0]?.[0]).toEqual(ThreadId.makeUnsafe("thread-1"));
     expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
-      cwd: "/tmp/provider-project",
+      cwd: harness.projectWorkspaceRoot,
       model: "gpt-5-codex",
       runtimeMode: "approval-required",
     });
@@ -316,6 +321,47 @@ describe("ProviderCommandReactor", () => {
     expect(thread?.session?.runtimeMode).toBe("approval-required");
   });
 
+  it("falls back to the project root and clears stale worktree paths before session start", async () => {
+    const missingWorktreePath = path.join(
+      os.tmpdir(),
+      `okcode-missing-worktree-${crypto.randomUUID()}`,
+    );
+    const harness = await createHarness({
+      worktreePath: missingWorktreePath,
+    });
+    const now = new Date().toISOString();
+
+    await Effect.runPromise(
+      harness.engine.dispatch({
+        type: "thread.turn.start",
+        commandId: CommandId.makeUnsafe("cmd-turn-start-stale-worktree"),
+        threadId: ThreadId.makeUnsafe("thread-1"),
+        message: {
+          messageId: asMessageId("user-message-stale-worktree"),
+          role: "user",
+          text: "recover stale worktree",
+          attachments: [],
+        },
+        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+        runtimeMode: "approval-required",
+        createdAt: now,
+      }),
+    );
+
+    await waitFor(() => harness.startSession.mock.calls.length === 1);
+    expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
+      cwd: harness.projectWorkspaceRoot,
+      model: "gpt-5-codex",
+      runtimeMode: "approval-required",
+    });
+
+    const readModel = await Effect.runPromise(harness.engine.getReadModel());
+    const thread = readModel.threads.find(
+      (entry) => entry.id === ThreadId.makeUnsafe("thread-1"),
+    );
+    expect(thread?.worktreePath).toBeNull();
+  });
+
   it("forwards codex model options through session start and turn send", async () => {
     const harness = await createHarness();
     const now = new Date().toISOString();

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+
 import {
   type ChatAttachment,
   CommandId,
@@ -140,6 +142,44 @@ function buildGeneratedWorktreeBranchName(raw: string): string {
   return `${WORKTREE_BRANCH_PREFIX}/${safeFragment}`;
 }
 
+function resolveSessionCwd(input: {
+  readonly thread: {
+    readonly id: ThreadId;
+    readonly projectId: string;
+    readonly worktreePath: string | null;
+  };
+  readonly projects: ReadonlyArray<{
+    readonly id: string;
+    readonly workspaceRoot: string;
+  }>;
+}): {
+  readonly cwd: string | undefined;
+  readonly staleWorktreePath: string | null;
+} {
+  const worktreePath = input.thread.worktreePath;
+  if (worktreePath) {
+    if (fs.existsSync(worktreePath)) {
+      return {
+        cwd: worktreePath,
+        staleWorktreePath: null,
+      };
+    }
+
+    const workspaceRoot = input.projects.find(
+      (project) => project.id === input.thread.projectId,
+    )?.workspaceRoot;
+    return {
+      cwd: workspaceRoot,
+      staleWorktreePath: worktreePath,
+    };
+  }
+
+  return {
+    cwd: resolveThreadWorkspaceCwd(input),
+    staleWorktreePath: null,
+  };
+}
+
 const make = Effect.gen(function* () {
   const orchestrationEngine = yield* OrchestrationEngineService;
   const providerService = yield* ProviderService;
@@ -254,11 +294,25 @@ const make = Effect.gen(function* () {
     }
     const preferredProvider: ProviderKind = currentProvider ?? threadProvider;
     const desiredModel = options?.model ?? thread.model;
-    const effectiveCwd = resolveThreadWorkspaceCwd({
+    const { cwd: effectiveCwd, staleWorktreePath } = resolveSessionCwd({
       thread,
       projects: readModel.projects,
     });
 
+    if (staleWorktreePath) {
+      yield* Effect.logWarning("provider command reactor clearing stale worktree path", {
+        threadId,
+        staleWorktreePath,
+        fallbackCwd: effectiveCwd ?? null,
+      });
+      yield* orchestrationEngine.dispatch({
+        type: "thread.meta.update",
+        commandId: serverCommandId("clear-stale-worktree-path"),
+        threadId,
+        worktreePath: null,
+      });
+    }
+
     const resolveActiveSession = (threadId: ThreadId) =>
       providerService
         .listSessions()