Make worktree placement configurable

apps/server/src/checkpointing/CheckpointDiffQuery.test.ts

@@ -85,6 +85,7 @@ describe("CheckpointDiffQuery.layer", () => {
               Effect.die("CheckpointDiffQuery should not request archived shell snapshots"),
             getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
             getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
+            getActiveProjectWorkspaceRoots: () => Effect.succeed([]),
             getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
             getProjectShellById: () => Effect.succeed(Option.none()),
             getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
@@ -193,6 +194,7 @@ describe("CheckpointDiffQuery.layer", () => {
               Effect.die("CheckpointDiffQuery should not request archived shell snapshots"),
             getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
             getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
+            getActiveProjectWorkspaceRoots: () => Effect.succeed([]),
             getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
             getProjectShellById: () => Effect.succeed(Option.none()),
             getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
@@ -276,6 +278,7 @@ describe("CheckpointDiffQuery.layer", () => {
               Effect.die("CheckpointDiffQuery should not request archived shell snapshots"),
             getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
             getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
+            getActiveProjectWorkspaceRoots: () => Effect.succeed([]),
             getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
             getProjectShellById: () => Effect.succeed(Option.none()),
             getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
@@ -344,6 +347,7 @@ describe("CheckpointDiffQuery.layer", () => {
               Effect.die("CheckpointDiffQuery should not request archived shell snapshots"),
             getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
             getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
+            getActiveProjectWorkspaceRoots: () => Effect.succeed([]),
             getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
             getProjectShellById: () => Effect.succeed(Option.none()),
             getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),
@@ -397,6 +401,7 @@ describe("CheckpointDiffQuery.layer", () => {
               Effect.die("CheckpointDiffQuery should not request archived shell snapshots"),
             getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 0 }),
             getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),
+            getActiveProjectWorkspaceRoots: () => Effect.succeed([]),
             getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
             getProjectShellById: () => Effect.succeed(Option.none()),
             getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),

apps/server/src/git/GitManager.ts

@@ -13,6 +13,7 @@ import * as Order from "effect/Order";
 import * as Path from "effect/Path";
 import * as Ref from "effect/Ref";
 import {
+  DEFAULT_WORKTREE_PATH_TEMPLATE,
   GitActionProgressEvent,
   GitActionProgressPhase,
   GitCommandError,
@@ -1807,6 +1808,14 @@ export const make = Effect.gen(function* () {
         cwd: input.cwd,
         refName: localPullRequestBranch,
         path: null,
+        pathTemplate: yield* serverSettingsService.getSettings.pipe(
+          Effect.map((settings) => settings.worktreePathTemplate),
+          Effect.catch((cause) =>
+            Effect.logWarning("Failed to read worktree path template; using the default", {
+              cause,
+            }).pipe(Effect.as(DEFAULT_WORKTREE_PATH_TEMPLATE)),
+          ),
+        ),
       });
       yield* ensureExistingWorktreeUpstream(worktree.worktree.path);
       yield* maybeRunSetupScript(worktree.worktree.path);

apps/server/src/git/GitWorkflowService.ts

@@ -63,7 +63,7 @@ export class GitWorkflowService extends Context.Service<
       input: VcsListRefsInput,
     ) => Effect.Effect<VcsListRefsResult, GitCommandError>;
     readonly createWorktree: (
-      input: VcsCreateWorktreeInput,
+      input: VcsCreateWorktreeInput & { readonly pathTemplate?: string },
     ) => Effect.Effect<VcsCreateWorktreeResult, GitCommandError>;
     readonly fetchRemote: (input: {
       readonly cwd: string;

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

@@ -195,6 +195,7 @@ describe("OrchestrationEngine", () => {
           getSnapshotSequence: () =>
             Effect.succeed({ snapshotSequence: projectionSnapshot.snapshotSequence }),
           getCounts: () => Effect.succeed({ projectCount: 1, threadCount: 1 }),
+          getActiveProjectWorkspaceRoots: () => Effect.succeed([]),
           getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),
           getProjectShellById: () => Effect.succeed(Option.none()),
           getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),

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

@@ -794,6 +794,8 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
           threadCount: 3,
         });
 
+        assert.deepEqual(yield* snapshotQuery.getActiveProjectWorkspaceRoots(), ["/tmp/workspace"]);
+
         const project = yield* snapshotQuery.getActiveProjectByWorkspaceRoot("/tmp/workspace");
         assert.equal(project._tag, "Some");
         if (project._tag === "Some") {

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

@@ -108,6 +108,9 @@ const ProjectionCountsRowSchema = Schema.Struct({
   projectCount: Schema.Number,
   threadCount: Schema.Number,
 });
+const ProjectionWorkspaceRootRowSchema = Schema.Struct({
+  workspaceRoot: Schema.String,
+});
 const WorkspaceRootLookupInput = Schema.Struct({
   workspaceRoot: Schema.String,
 });
@@ -316,6 +319,18 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
       `,
   });
 
+  const listActiveProjectWorkspaceRootRows = SqlSchema.findAll({
+    Request: Schema.Void,
+    Result: ProjectionWorkspaceRootRowSchema,
+    execute: () =>
+      sql`
+        SELECT workspace_root AS "workspaceRoot"
+        FROM projection_projects
+        WHERE deleted_at IS NULL
+        ORDER BY created_at ASC, project_id ASC
+      `,
+  });
+
   const listThreadRows = SqlSchema.findAll({
     Request: Schema.Void,
     Result: ProjectionThreadDbRowSchema,
@@ -1737,6 +1752,18 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
       ),
     );
 
+  const getActiveProjectWorkspaceRoots: ProjectionSnapshotQueryShape["getActiveProjectWorkspaceRoots"] =
+    () =>
+      listActiveProjectWorkspaceRootRows(undefined).pipe(
+        Effect.mapError(
+          toPersistenceSqlOrDecodeError(
+            "ProjectionSnapshotQuery.getActiveProjectWorkspaceRoots:query",
+            "ProjectionSnapshotQuery.getActiveProjectWorkspaceRoots:decodeRows",
+          ),
+        ),
+        Effect.map((rows) => rows.map((row) => row.workspaceRoot)),
+      );
+
   const getActiveProjectByWorkspaceRoot: ProjectionSnapshotQueryShape["getActiveProjectByWorkspaceRoot"] =
     (workspaceRoot) =>
       getActiveProjectRowByWorkspaceRoot({ workspaceRoot }).pipe(
@@ -2110,6 +2137,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
     getArchivedShellSnapshot,
     getSnapshotSequence,
     getCounts,
+    getActiveProjectWorkspaceRoots,
     getActiveProjectByWorkspaceRoot,
     getProjectShellById,
     getFirstActiveThreadIdByProjectId,

apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts

@@ -108,6 +108,14 @@ export interface ProjectionSnapshotQueryShape {
    */
   readonly getCounts: () => Effect.Effect<ProjectionSnapshotCounts, ProjectionRepositoryError>;
 
+  /**
+   * Read only the workspace roots for active projects.
+   */
+  readonly getActiveProjectWorkspaceRoots: () => Effect.Effect<
+    ReadonlyArray<string>,
+    ProjectionRepositoryError
+  >;
+
   /**
    * Read the active project for an exact workspace root match.
    */

apps/server/src/project/ProjectSetupScriptRunner.test.ts

@@ -32,6 +32,7 @@ const makeProjectionSnapshotQueryLayer = (project: OrchestrationProject) =>
     getArchivedShellSnapshot: () => Effect.die("unused"),
     getSnapshotSequence: () => Effect.succeed({ snapshotSequence: 1 }),
     getCounts: () => Effect.die("unused"),
+    getActiveProjectWorkspaceRoots: () => Effect.die("unused"),
     getActiveProjectByWorkspaceRoot: (workspaceRoot) =>
       Effect.succeed(
         workspaceRoot === project.workspaceRoot ? Option.some(project) : Option.none(),

apps/server/src/provider/Layers/ProviderSessionReaper.test.ts

@@ -199,6 +199,7 @@ describe("ProviderSessionReaper", () => {
           getSnapshotSequence: () =>
             Effect.succeed({ snapshotSequence: input.readModel.snapshotSequence }),
           getCounts: () => Effect.die("unused"),
+          getActiveProjectWorkspaceRoots: () => Effect.die("unused"),
           getActiveProjectByWorkspaceRoot: () => Effect.die("unused"),
           getProjectShellById: () => Effect.die("unused"),
           getFirstActiveThreadIdByProjectId: () => Effect.die("unused"),

apps/server/src/review/ReviewService.test.ts

@@ -3,16 +3,19 @@ import { assert, describe, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
 import * as PlatformError from "effect/PlatformError";
 
 import { ServerConfig } from "../config.ts";
+import * as ServerSettings from "../serverSettings.ts";
 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
 import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
 import * as ReviewService from "./ReviewService.ts";
 
 function makeLayer(input: {
   readonly workspaceRoot: string;
   readonly baseDir: string;
+  readonly worktreePathTemplate?: string;
   readonly detectCalls?: Array<{ readonly cwd: string }>;
 }) {
   return ReviewService.layer.pipe(
@@ -28,6 +31,11 @@ function makeLayer(input: {
       }),
     ),
     Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})),
+    Layer.provide(
+      ServerSettings.ServerSettingsService.layerTest(
+        input.worktreePathTemplate ? { worktreePathTemplate: input.worktreePathTemplate } : {},
+      ),
+    ),
     Layer.provide(ServerConfig.layerTest(input.workspaceRoot, input.baseDir)),
     Layer.provideMerge(NodeServices.layer),
   );
@@ -75,6 +83,163 @@ describe("ReviewService", () => {
     }).pipe(Effect.provide(NodeServices.layer)),
   );
 
+  it.effect("allows diff preview cwd matching the configured worktree template", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspaceRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-workspace-" });
+      const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-base-" });
+      const repositoryRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-repo-" });
+      const repositoryAliasesRoot = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3-review-repo-aliases-",
+      });
+      const repositoryRootAlias = path.join(repositoryAliasesRoot, "repo");
+      const worktreeRoot = path.join(repositoryRoot, ".worktrees", "feature-local");
+      const detectCalls: Array<{ readonly cwd: string }> = [];
+      yield* fs.symlink(repositoryRoot, repositoryRootAlias);
+      yield* fs.makeDirectory(worktreeRoot, { recursive: true });
+
+      const result = yield* Effect.gen(function* () {
+        const review = yield* ReviewService.ReviewService;
+        return yield* review.getDiffPreview({
+          cwd: worktreeRoot,
+          repositoryRoots: [repositoryRootAlias],
+        });
+      }).pipe(
+        Effect.provide(
+          makeLayer({
+            workspaceRoot,
+            baseDir,
+            detectCalls,
+            worktreePathTemplate: "{repoRoot}/.worktrees/{branch}",
+          }),
+        ),
+      );
+
+      assert.strictEqual(result.cwd, worktreeRoot);
+      assert.deepStrictEqual(result.sources, []);
+      assert.deepStrictEqual(detectCalls, [{ cwd: worktreeRoot }]);
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
+  it.effect("preserves lexical repo names when matching canonical worktree paths", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspaceRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-workspace-" });
+      const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-base-" });
+      const repositoryParent = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3-review-repo-parent-",
+      });
+      const repositoryRoot = path.join(repositoryParent, "physical-repo-name");
+      const repositoryRootAlias = path.join(repositoryParent, "lexical-repo-name");
+      const worktreeRoot = path.join(
+        repositoryParent,
+        "lexical-repo-name-worktrees",
+        "feature-local",
+      );
+      const detectCalls: Array<{ readonly cwd: string }> = [];
+      yield* fs.makeDirectory(repositoryRoot);
+      yield* fs.symlink(repositoryRoot, repositoryRootAlias);
+      yield* fs.makeDirectory(worktreeRoot, { recursive: true });
+
+      const result = yield* Effect.gen(function* () {
+        const review = yield* ReviewService.ReviewService;
+        return yield* review.getDiffPreview({
+          cwd: worktreeRoot,
+          repositoryRoots: [repositoryRootAlias],
+        });
+      }).pipe(
+        Effect.provide(
+          makeLayer({
+            workspaceRoot,
+            baseDir,
+            detectCalls,
+            worktreePathTemplate: "{repoRoot}/../{repoName}-worktrees/{branch}",
+          }),
+        ),
+      );
+
+      assert.strictEqual(result.cwd, worktreeRoot);
+      assert.deepStrictEqual(result.sources, []);
+      assert.deepStrictEqual(detectCalls, [{ cwd: worktreeRoot }]);
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
+  it.effect("skips invalid unrelated repository roots", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspaceRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-workspace-" });
+      const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-base-" });
+      const repositoryRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-repo-" });
+      const worktreeRoot = path.join(repositoryRoot, ".worktrees", "feature-local");
+      const detectCalls: Array<{ readonly cwd: string }> = [];
+      yield* fs.makeDirectory(worktreeRoot, { recursive: true });
+
+      const result = yield* Effect.gen(function* () {
+        const review = yield* ReviewService.ReviewService;
+        return yield* review.getDiffPreview({
+          cwd: worktreeRoot,
+          repositoryRoots: [`${repositoryRoot}\0invalid`, repositoryRoot],
+        });
+      }).pipe(
+        Effect.provide(
+          makeLayer({
+            workspaceRoot,
+            baseDir,
+            detectCalls,
+            worktreePathTemplate: "{repoRoot}/.worktrees/{branch}",
+          }),
+        ),
+      );
+
+      assert.strictEqual(result.cwd, worktreeRoot);
+      assert.deepStrictEqual(result.sources, []);
+      assert.deepStrictEqual(detectCalls, [{ cwd: worktreeRoot }]);
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
+  it.effect("rejects configured-template paths outside known repository roots", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspaceRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-workspace-" });
+      const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-base-" });
+      const knownRepositoryRoot = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3-review-known-repo-",
+      });
+      const unknownRepositoryRoot = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3-review-unknown-repo-",
+      });
+      const unknownWorktreeRoot = path.join(unknownRepositoryRoot, ".worktrees", "feature-local");
+      const detectCalls: Array<{ readonly cwd: string }> = [];
+      yield* fs.makeDirectory(unknownWorktreeRoot, { recursive: true });
+
+      const error = yield* Effect.gen(function* () {
+        const review = yield* ReviewService.ReviewService;
+        return yield* review
+          .getDiffPreview({
+            cwd: unknownWorktreeRoot,
+            repositoryRoots: [knownRepositoryRoot],
+          })
+          .pipe(Effect.flip);
+      }).pipe(
+        Effect.provide(
+          makeLayer({
+            workspaceRoot,
+            baseDir,
+            detectCalls,
+            worktreePathTemplate: "{repoRoot}/.worktrees/{branch}",
+          }),
+        ),
+      );
+
+      assert.strictEqual(error._tag, "VcsRepositoryDetectionError");
+      assert.deepStrictEqual(detectCalls, []);
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
   it.effect("preserves unexpected path-resolution failures", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;