gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/worktree-lifecycle.test.ts

@@ -0,0 +1,434 @@
+// Project/App: GSD-2
+// File Purpose: Worktree Lifecycle Module — typed-result contract tests for enterMilestone (ADR-016).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  WorktreeLifecycle,
+  type WorktreeLifecycleDeps,
+  type NotifyCtx,
+} from "../worktree-lifecycle.js";
+import { WorktreeStateProjection } from "../worktree-state-projection.js";
+import { AutoSession } from "../auto/session.js";
+import { openDatabase, closeDatabase, insertMilestone } from "../gsd-db.js";
+import { registerAutoWorker } from "../db/auto-workers.js";
+import { claimMilestoneLease } from "../db/milestone-leases.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+interface CallLog {
+  fn: string;
+  args: unknown[];
+}
+
+function makeSession(overrides?: Partial<AutoSession>): AutoSession {
+  const s = new AutoSession();
+  s.basePath = overrides?.basePath ?? "/project";
+  s.originalBasePath = overrides?.originalBasePath ?? "/project";
+  Object.assign(s, overrides);
+  return s;
+}
+
+function makeDeps(
+  overrides?: Partial<WorktreeLifecycleDeps>,
+): WorktreeLifecycleDeps & { calls: CallLog[] } {
+  const calls: CallLog[] = [];
+  const deps: WorktreeLifecycleDeps & { calls: CallLog[] } = {
+    calls,
+    enterAutoWorktree: (basePath, milestoneId) => {
+      calls.push({ fn: "enterAutoWorktree", args: [basePath, milestoneId] });
+      return `/project/.gsd/worktrees/${milestoneId}`;
+    },
+    createAutoWorktree: (basePath, milestoneId) => {
+      calls.push({ fn: "createAutoWorktree", args: [basePath, milestoneId] });
+      return `/project/.gsd/worktrees/${milestoneId}`;
+    },
+    enterBranchModeForMilestone: (basePath, milestoneId) => {
+      calls.push({
+        fn: "enterBranchModeForMilestone",
+        args: [basePath, milestoneId],
+      });
+    },
+    getAutoWorktreePath: (basePath, milestoneId) => {
+      calls.push({ fn: "getAutoWorktreePath", args: [basePath, milestoneId] });
+      return null;
+    },
+    getIsolationMode: () => {
+      calls.push({ fn: "getIsolationMode", args: [] });
+      return "worktree";
+    },
+    invalidateAllCaches: () => {
+      calls.push({ fn: "invalidateAllCaches", args: [] });
+    },
+    GitServiceImpl: class MockGitService {
+      basePath: string;
+      gitConfig: unknown;
+      constructor(basePath: string, gitConfig: unknown) {
+        calls.push({ fn: "GitServiceImpl", args: [basePath, gitConfig] });
+        this.basePath = basePath;
+        this.gitConfig = gitConfig;
+      }
+    } as unknown as WorktreeLifecycleDeps["GitServiceImpl"],
+    loadEffectiveGSDPreferences: () => {
+      calls.push({ fn: "loadEffectiveGSDPreferences", args: [] });
+      return { preferences: { git: {} } };
+    },
+    // Slice 7 widened WorktreeLifecycleDeps with merge/exit-side fields.
+    // These tests focus on enter; merge-side helpers are no-op stubs.
+    worktreeProjection: new WorktreeStateProjection(),
+    isInAutoWorktree: () => false,
+    autoCommitCurrentBranch: () => {},
+    autoWorktreeBranch: (mid: string) => `milestone/${mid}`,
+    teardownAutoWorktree: () => {},
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    getCurrentBranch: () => "main",
+    checkoutBranch: () => {},
+    resolveMilestoneFile: () => null,
+    readFileSync: () => "",
+    ...overrides,
+  };
+  return deps;
+}
+
+function makeCtx(): NotifyCtx & {
+  messages: Array<{ msg: string; level?: string }>;
+} {
+  const messages: Array<{ msg: string; level?: string }> = [];
+  return {
+    messages,
+    notify: (msg, level) => {
+      messages.push({ msg, level });
+    },
+  };
+}
+
+function makeDbBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-lifecycle-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanupDbBase(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── enterMilestone — typed-result contract ──────────────────────────────────
+
+test("enterMilestone returns ok:true mode:worktree on successful create", () => {
+  const s = makeSession();
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, true);
+  if (result.ok) {
+    assert.equal(result.mode, "worktree");
+    assert.equal(result.path, "/project/.gsd/worktrees/M001");
+  }
+  assert.equal(s.basePath, "/project/.gsd/worktrees/M001");
+  assert.equal(
+    deps.calls.filter((c) => c.fn === "invalidateAllCaches").length,
+    1,
+  );
+});
+
+test("enterMilestone returns ok:true mode:branch on successful branch fallback", () => {
+  const s = makeSession();
+  const deps = makeDeps({ getIsolationMode: () => "branch" });
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, true);
+  if (result.ok) {
+    assert.equal(result.mode, "branch");
+    assert.equal(result.path, "/project");
+  }
+  // Branch mode does not mutate s.basePath
+  assert.equal(s.basePath, "/project");
+});
+
+test("enterMilestone returns ok:true mode:none when isolation disabled", () => {
+  const s = makeSession();
+  const deps = makeDeps({ getIsolationMode: () => "none" });
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, true);
+  if (result.ok) {
+    assert.equal(result.mode, "none");
+    assert.equal(result.path, "/project");
+  }
+  assert.equal(s.basePath, "/project");
+});
+
+test("enterMilestone returns ok:false reason:isolation-degraded when session degraded", () => {
+  const s = makeSession({ isolationDegraded: true });
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.equal(result.reason, "isolation-degraded");
+  }
+  // No worktree primitives invoked
+  assert.equal(deps.calls.filter((c) => c.fn === "createAutoWorktree").length, 0);
+  assert.equal(deps.calls.filter((c) => c.fn === "enterAutoWorktree").length, 0);
+});
+
+test("enterMilestone returns ok:false reason:creation-failed and degrades session on worktree throw", () => {
+  const s = makeSession();
+  const deps = makeDeps({
+    createAutoWorktree: () => {
+      throw new Error("boom");
+    },
+  });
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.equal(result.reason, "creation-failed");
+    assert.ok(result.cause instanceof Error);
+  }
+  assert.equal(s.isolationDegraded, true);
+  // s.basePath unchanged on failure
+  assert.equal(s.basePath, "/project");
+});
+
+test("enterMilestone returns ok:false reason:creation-failed when branch mode throws", () => {
+  const s = makeSession();
+  const deps = makeDeps({
+    getIsolationMode: () => "branch",
+    enterBranchModeForMilestone: () => {
+      throw new Error("branch checkout failed");
+    },
+  });
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.equal(result.reason, "creation-failed");
+  }
+  assert.equal(s.isolationDegraded, true);
+});
+
+test("enterMilestone enters existing worktree when path resolves", () => {
+  const s = makeSession();
+  const deps = makeDeps({
+    getAutoWorktreePath: () => "/project/.gsd/worktrees/M001",
+  });
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, true);
+  assert.equal(deps.calls.filter((c) => c.fn === "enterAutoWorktree").length, 1);
+  assert.equal(deps.calls.filter((c) => c.fn === "createAutoWorktree").length, 0);
+});
+
+test("enterMilestone returns ok:false reason:lease-conflict when another worker holds the lease", (t) => {
+  const base = makeDbBase();
+  t.after(() => cleanupDbBase(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  const holder = registerAutoWorker({ projectRootRealpath: base });
+  const contender = registerAutoWorker({ projectRootRealpath: base });
+  const claim = claimMilestoneLease(holder, "M001");
+  assert.equal(claim.ok, true);
+
+  const s = makeSession({ basePath: base, originalBasePath: base, workerId: contender });
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.equal(result.reason, "lease-conflict");
+  }
+  assert.equal(s.isolationDegraded, false);
+  assert.equal(deps.calls.filter((c) => c.fn === "createAutoWorktree").length, 0);
+  assert.equal(deps.calls.filter((c) => c.fn === "enterAutoWorktree").length, 0);
+});
+
+test("enterMilestone is idempotent when already in the milestone worktree", () => {
+  const s = makeSession({
+    basePath: "/project/.gsd/worktrees/M001",
+    originalBasePath: "/project",
+    currentMilestoneId: "M001",
+  });
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const result = lifecycle.enterMilestone("M001", ctx);
+
+  assert.equal(result.ok, true);
+  if (result.ok) {
+    assert.equal(result.mode, "worktree");
+    assert.equal(result.path, "/project/.gsd/worktrees/M001");
+  }
+  assert.equal(s.basePath, "/project/.gsd/worktrees/M001");
+  assert.equal(deps.calls.filter((c) => c.fn === "createAutoWorktree").length, 0);
+  assert.equal(deps.calls.filter((c) => c.fn === "enterAutoWorktree").length, 0);
+});
+
+test("enterMilestone returns ok:false reason:invalid-milestone-id on path traversal", () => {
+  const s = makeSession();
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  const traversal = lifecycle.enterMilestone("../escape", ctx);
+  const separator = lifecycle.enterMilestone("a/b", ctx);
+
+  assert.equal(traversal.ok, false);
+  if (!traversal.ok) {
+    assert.equal(traversal.reason, "invalid-milestone-id");
+  }
+  assert.equal(separator.ok, false);
+  if (!separator.ok) {
+    assert.equal(separator.reason, "invalid-milestone-id");
+  }
+});
+
+// ─── exitMilestone — typed-result contract ────────────────────────────────────
+//
+// The delegation-shape tests that lived here were retired in slice 7 / step
+// D of ADR-016: Lifecycle no longer takes a `resolverFactory`. The merge
+// behaviour they covered now runs inside Lifecycle directly and is exercised
+// end-to-end by the merge-mode tests in worktree-resolver.test.ts (which
+// drive Lifecycle through Resolver delegation until step E retires the
+// Resolver class entirely). When that retirement lands, those tests move
+// here verbatim.
+
+// ─── Queries (issue #5587) ────────────────────────────────────────────────────
+
+test("isInMilestone returns true when session matches milestone id", () => {
+  const s = makeSession();
+  s.currentMilestoneId = "M001";
+  const lifecycle = new WorktreeLifecycle(s, makeDeps());
+
+  assert.equal(lifecycle.isInMilestone("M001"), true);
+  assert.equal(lifecycle.isInMilestone("M002"), false);
+});
+
+test("isInMilestone returns false when session has no active milestone", () => {
+  const s = makeSession();
+  s.currentMilestoneId = null;
+  const lifecycle = new WorktreeLifecycle(s, makeDeps());
+
+  assert.equal(lifecycle.isInMilestone("M001"), false);
+});
+
+test("getCurrentMilestoneIfAny returns the active milestone id or null", () => {
+  const s = makeSession();
+  s.currentMilestoneId = "M042";
+  const lifecycle = new WorktreeLifecycle(s, makeDeps());
+
+  assert.equal(lifecycle.getCurrentMilestoneIfAny(), "M042");
+
+  s.currentMilestoneId = null;
+  assert.equal(lifecycle.getCurrentMilestoneIfAny(), null);
+});
+
+// ─── degradeToBranchMode (issue #5587) ────────────────────────────────────────
+
+test("degradeToBranchMode sets isolationDegraded and invokes branch-mode helper", () => {
+  const s = makeSession();
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  lifecycle.degradeToBranchMode("M001", ctx);
+
+  assert.equal(s.isolationDegraded, true);
+  assert.equal(
+    deps.calls.filter((c) => c.fn === "enterBranchModeForMilestone").length,
+    1,
+  );
+  assert.equal(deps.calls.filter((c) => c.fn === "invalidateAllCaches").length, 1);
+});
+
+test("degradeToBranchMode is no-op when isolationDegraded is already true", () => {
+  const s = makeSession();
+  s.isolationDegraded = true;
+  const deps = makeDeps();
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  lifecycle.degradeToBranchMode("M001", ctx);
+
+  assert.equal(
+    deps.calls.filter((c) => c.fn === "enterBranchModeForMilestone").length,
+    0,
+  );
+});
+
+test("degradeToBranchMode marks degraded and notifies on branch-mode failure", () => {
+  const s = makeSession();
+  const deps = makeDeps({
+    enterBranchModeForMilestone: () => {
+      throw new Error("checkout failed");
+    },
+  });
+  const ctx = makeCtx();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  lifecycle.degradeToBranchMode("M001", ctx);
+
+  assert.equal(s.isolationDegraded, true);
+  assert.ok(
+    ctx.messages.some(
+      (m) => m.level === "warning" && m.msg.includes("Branch isolation setup"),
+    ),
+  );
+});
+
+// ─── restoreToProjectRoot (issue #5587) ───────────────────────────────────────
+
+test("restoreToProjectRoot restores basePath to originalBasePath and rebuilds git service", () => {
+  const s = makeSession();
+  s.originalBasePath = "/project";
+  s.basePath = "/project/.gsd/worktrees/M001";
+  const deps = makeDeps();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  lifecycle.restoreToProjectRoot();
+
+  assert.equal(s.basePath, "/project");
+  assert.equal(deps.calls.filter((c) => c.fn === "GitServiceImpl").length, 1);
+  assert.equal(deps.calls.filter((c) => c.fn === "invalidateAllCaches").length, 1);
+});
+
+test("restoreToProjectRoot is no-op when originalBasePath is empty", () => {
+  const s = makeSession();
+  s.originalBasePath = "";
+  s.basePath = "/some/path";
+  const deps = makeDeps();
+  const lifecycle = new WorktreeLifecycle(s, deps);
+
+  lifecycle.restoreToProjectRoot();
+
+  assert.equal(s.basePath, "/some/path"); // unchanged
+  assert.equal(deps.calls.filter((c) => c.fn === "GitServiceImpl").length, 0);
+});

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -1,25 +1,27 @@
-/**
- * Regression test for #3461: createAutoWorktree must use git.main_branch
- * preference when META.json integration branch is absent.
- */
+// GSD-2 — Auto-worktree main branch preference regression tests.
+
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
-test("auto-worktree.ts includes main_branch preference in startPoint fallback (#3461)", () => {
-  const src = readFileSync(
-    join(import.meta.dirname, "..", "auto-worktree.ts"),
-    "utf-8",
+import { _resolveAutoWorktreeStartPoint } from "../auto-worktree.ts";
+
+test("auto-worktree start point prefers milestone integration branch", () => {
+  const startPoint = _resolveAutoWorktreeStartPoint(
+    "release/integration",
+    "dev",
+    () => true,
   );
-  // The fix adds gitPrefs?.main_branch to the startPoint fallback chain
-  assert.ok(
-    src.includes("gitPrefs?.main_branch") || src.includes("prefs.main_branch"),
-    "createAutoWorktree must check git.main_branch preference before falling back to nativeDetectMainBranch",
+
+  assert.equal(startPoint, "release/integration");
+});
+
+test("auto-worktree start point uses git.main_branch only when it exists", () => {
+  assert.equal(
+    _resolveAutoWorktreeStartPoint(null, "dev", (branch) => branch === "dev"),
+    "dev",
   );
-  assert.match(
-    src,
-    /nativeBranchExists\(basePath,\s*gitPrefs\.main_branch\)/,
-    "createAutoWorktree must validate git.main_branch exists before using it",
+  assert.equal(
+    _resolveAutoWorktreeStartPoint(null, "stale", () => false),
+    undefined,
   );
 });

package/src/resources/extensions/gsd/tests/worktree-path-injection.test.ts

@@ -79,7 +79,7 @@ async function waitFor(condition: () => boolean, label: string): Promise<void> {
   assert.fail(`Timed out waiting for ${label} after ${timeoutMs}ms`);
 }
 
-test("runUnit changes cwd to basePath before creating a new session", async (t) => {
+test("runUnit passes basePath as workspaceRoot without changing process cwd", async (t) => {
   _resetPendingResolve();
 
   const originalCwd = process.cwd();
@@ -93,13 +93,15 @@ test("runUnit changes cwd to basePath before creating a new session", async (t)
 
   process.chdir(drifted);
 
+  let newSessionWorkspaceRoot: string | undefined;
   let cwdAtNewSession: string | undefined;
   const session = {
     active: true,
     basePath: base,
     verbose: false,
     cmdCtx: {
-      newSession: () => {
+      newSession: (options?: { workspaceRoot?: string }) => {
+        newSessionWorkspaceRoot = options?.workspaceRoot;
         cwdAtNewSession = process.cwd();
         return Promise.resolve({ cancelled: false });
       },
@@ -119,10 +121,12 @@ test("runUnit changes cwd to basePath before creating a new session", async (t)
 
   const result = await resultPromise;
   assert.equal(result.status, "completed");
-  assert.equal(cwdAtNewSession, base);
+  assert.equal(newSessionWorkspaceRoot, base);
+  assert.equal(cwdAtNewSession, drifted);
+  assert.equal(process.cwd(), drifted);
 });
 
-test("runUnit cancels before creating a session when basePath chdir fails", async (t) => {
+test("runUnit does not chdir or cancel when basePath is not a live directory", async (t) => {
   _resetPendingResolve();
 
   const originalCwd = process.cwd();
@@ -136,14 +140,14 @@ test("runUnit cancels before creating a session when basePath chdir fails", asyn
 
   process.chdir(drifted);
 
-  let newSessionCalled = false;
+  let newSessionWorkspaceRoot: string | undefined;
   const session = {
     active: true,
     basePath: base,
     verbose: false,
     cmdCtx: {
-      newSession: () => {
-        newSessionCalled = true;
+      newSession: (options?: { workspaceRoot?: string }) => {
+        newSessionWorkspaceRoot = options?.workspaceRoot;
         return Promise.resolve({ cancelled: false });
       },
     },
@@ -156,15 +160,14 @@ test("runUnit cancels before creating a session when basePath chdir fails", asyn
   } as any;
   const ctx = { ui: { notify: () => {} }, model: { id: "test-model" } } as any;
 
-  const result = await runUnit(ctx, pi, session, "task", "T01", "prompt");
+  const resultPromise = runUnit(ctx, pi, session, "task", "T01", "prompt");
+  await waitFor(() => pi.calls.length === 1, "runUnit dispatch");
+  resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
-  assert.equal(result.status, "cancelled");
-  assert.equal(result.errorContext?.category, "session-failed");
-  assert.equal(result.errorContext?.isTransient, true);
-  assert.match(result.errorContext?.message ?? "", /Failed to chdir to basePath before newSession/);
-  assert.ok(result.errorContext?.message.includes(base), "error should include the failed basePath");
-  assert.equal(newSessionCalled, false, "newSession must not run after chdir failure");
-  assert.equal(pi.calls.length, 0, "unit must not dispatch after chdir failure");
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.equal(newSessionWorkspaceRoot, base);
+  assert.equal(process.cwd(), drifted);
 });
 
 test("direct dispatch redirects to the canonical milestone worktree before newSession", async (t) => {
@@ -185,12 +188,12 @@ test("direct dispatch redirects to the canonical milestone worktree before newSe
 
   process.chdir(drifted);
 
-  let cwdAtNewSession: string | undefined;
+  let newSessionWorkspaceRoot: string | undefined;
   let sentPrompt: string | undefined;
   const ctx = {
     ui: { notify: () => {} },
-    newSession: async () => {
-      cwdAtNewSession = process.cwd();
+    newSession: async (options?: { workspaceRoot?: string }) => {
+      newSessionWorkspaceRoot = options?.workspaceRoot;
       return { cancelled: false };
     },
   } as any;
@@ -202,7 +205,7 @@ test("direct dispatch redirects to the canonical milestone worktree before newSe
 
   await dispatchDirectPhase(ctx, pi, "research-milestone", base);
 
-  assert.equal(cwdAtNewSession, worktreeRoot);
+  assert.equal(newSessionWorkspaceRoot, worktreeRoot);
   assert.equal(process.cwd(), drifted);
   assert.ok(sentPrompt?.includes(worktreeRoot), "prompt should name the canonical worktree root");
 });

package/src/resources/extensions/gsd/tests/worktree-project-root-degrade.test.ts

@@ -0,0 +1,66 @@
+// GSD-2 + Worktree dispatch guard: degrade empty worktrees over real project roots.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldDegradeEmptyWorktreeToProjectRoot } from "../auto/phases.ts";
+import type { ProjectClassification } from "../detection.ts";
+
+function classification(kind: ProjectClassification["kind"]): ProjectClassification {
+  return {
+    kind,
+    signals: {
+      detectedFiles: [],
+      isGitRepo: true,
+      isMonorepo: false,
+      xcodePlatforms: [],
+      hasCI: false,
+      hasTests: false,
+      verificationCommands: [],
+    },
+    trackedFiles: [],
+    untrackedFiles: [],
+    contentFiles: [],
+    markers: [],
+    reason: kind,
+  };
+}
+
+describe("worktree project-root degradation", () => {
+  test("degrades when worktree is greenfield but project root has content", () => {
+    assert.equal(
+      shouldDegradeEmptyWorktreeToProjectRoot(
+        classification("greenfield"),
+        classification("typed-existing"),
+      ),
+      true,
+    );
+    assert.equal(
+      shouldDegradeEmptyWorktreeToProjectRoot(
+        classification("greenfield"),
+        classification("untyped-existing"),
+      ),
+      true,
+    );
+  });
+
+  test("keeps true greenfield worktrees in worktree mode", () => {
+    assert.equal(
+      shouldDegradeEmptyWorktreeToProjectRoot(
+        classification("greenfield"),
+        classification("greenfield"),
+      ),
+      false,
+    );
+  });
+
+  test("does not degrade when project root classification is invalid", () => {
+    assert.equal(
+      shouldDegradeEmptyWorktreeToProjectRoot(
+        classification("greenfield"),
+        classification("invalid-repo"),
+      ),
+      false,
+    );
+  });
+});