gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

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,
+    );
+  });
+});

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

@@ -0,0 +1,327 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for the Worktree Safety module contract.
+
+import { afterEach, beforeEach, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { createWorktreeSafetyModule } from "../worktree-safety.ts";
+import { createWorktree, worktreePath } from "../worktree-manager.ts";
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeBaseRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-wt-safety-repo-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+  return base;
+}
+
+describe("Worktree Safety module", () => {
+  let root: string;
+  let projectRoot: string;
+  let unitRoot: string;
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "gsd-worktree-safety-"));
+    projectRoot = join(root, "project");
+    unitRoot = join(projectRoot, ".gsd", "worktrees", "M001");
+    mkdirSync(unitRoot, { recursive: true });
+    writeFileSync(join(unitRoot, ".git"), "gitdir: ../../../.git/worktrees/M001\n", "utf-8");
+  });
+
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test("allows planning-only Units without requiring a source worktree", () => {
+    const safety = createWorktreeSafetyModule();
+
+    const result = safety.validateUnitRoot({
+      unitType: "plan-milestone",
+      unitId: "M001",
+      writeScope: "planning-only",
+      projectRoot,
+      unitRoot: projectRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.kind, "not-required");
+  });
+
+  test("accepts a source-writing Unit with a registered worktree and expected branch", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "milestone/M001" }],
+      getCurrentBranch: () => "milestone/M001",
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.kind, "safe");
+    assert.equal(result.milestoneId, "M001");
+    assert.equal(result.branch, "milestone/M001");
+  });
+
+  test("rejects a source-writing Unit when the worktree root is missing", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: (path) => path !== unitRoot,
+      lstatSync: () => ({ isFile: () => true }),
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-missing");
+    assert.match(result.remediation, /Create or recover/);
+  });
+
+  test("rejects a source-writing Unit outside the expected milestone worktree root", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+    });
+
+    const outsideRoot = join(projectRoot, "src");
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot: outsideRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "invalid-root");
+    assert.equal(result.details?.unitRoot, outsideRoot);
+    assert.equal(result.details?.expectedRoot, unitRoot);
+  });
+
+  test("rejects a standalone repository masquerading as a worktree", () => {
+    unlinkSync(join(unitRoot, ".git"));
+    mkdirSync(join(unitRoot, ".git"), { recursive: true });
+    const safety = createWorktreeSafetyModule();
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-git-marker-not-file");
+  });
+
+  test("converts .git marker stat failures into typed failures", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => {
+        throw new Error("marker disappeared");
+      },
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-git-probe-failed");
+    assert.equal(result.details?.error, "marker disappeared");
+  });
+
+  test("rejects an unregistered worktree path", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [],
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-unregistered");
+  });
+
+  test("converts registered worktree list failures into typed failures", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => {
+        throw new Error("worktree list unreadable");
+      },
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-git-probe-failed");
+    assert.equal(result.details?.error, "worktree list unreadable");
+  });
+
+  test("rejects a branch mismatch with a typed failure", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "milestone/M001" }],
+      getCurrentBranch: () => "feature/unexpected",
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "branch-mismatch");
+    assert.equal(result.details?.branch, "feature/unexpected");
+  });
+
+  test("converts branch resolution failures into typed failures", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "milestone/M001" }],
+      getCurrentBranch: () => {
+        throw new Error("branch unreadable");
+      },
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-git-probe-failed");
+    assert.equal(result.details?.expectedBranch, "milestone/M001");
+    assert.equal(result.details?.error, "branch unreadable");
+  });
+
+  test("fails closed when branch verification lacks a branch probe", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "milestone/M001" }],
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-git-probe-failed");
+    assert.equal(result.details?.error, "getCurrentBranch dep not provided");
+  });
+
+  test("rejects an empty worktree when the project root has content", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "milestone/M001" }],
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      emptyWorktreeWithProjectContent: true,
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "empty-worktree-with-project-content");
+  });
+
+  test("default adapter proves registered worktree and current branch", (t) => {
+    const base = makeBaseRepo();
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+    createWorktree(base, "M001", { branch: "milestone/M001" });
+
+    const safety = createWorktreeSafetyModule();
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot: base,
+      unitRoot: worktreePath(base, "M001"),
+      milestoneId: "M001",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.kind, "safe");
+    assert.equal(result.branch, "milestone/M001");
+  });
+});

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

@@ -0,0 +1,120 @@
+// Project/App: GSD-2
+// File Purpose: Worktree State Projection Module — typed-Interface contract tests for projectRootToWorktree (ADR-016).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { WorktreeStateProjection } from "../worktree-state-projection.js";
+import { createWorkspace, scopeMilestone } from "../workspace.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectRoot(): { dir: string; cleanup: () => void } {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-projection-"));
+  // .gsd directory is required for the workspace contract resolution
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return {
+    dir,
+    cleanup: () => rmSync(dir, { recursive: true, force: true }),
+  };
+}
+
+// ─── projectRootToWorktree — Module contract ────────────────────────────────
+
+test("WorktreeStateProjection can be constructed without arguments", () => {
+  const projection = new WorktreeStateProjection();
+  assert.ok(projection);
+  assert.equal(typeof projection.projectRootToWorktree, "function");
+});
+
+test("projectRootToWorktree accepts a MilestoneScope without throwing on same-path scope", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const workspace = createWorkspace(dir);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    // When the scope's workspace has no worktreeRoot (project-only mode),
+    // the underlying syncProjectRootToWorktree fast-paths to a no-op when
+    // both endpoints resolve to the same path. The Module must accept
+    // this scope and complete silently.
+    assert.doesNotThrow(() => projection.projectRootToWorktree(scope));
+  } finally {
+    cleanup();
+  }
+});
+
+test("projectRootToWorktree is idempotent — repeated calls do not throw", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const workspace = createWorkspace(dir);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    projection.projectRootToWorktree(scope);
+    projection.projectRootToWorktree(scope);
+    assert.ok(true, "two calls did not throw");
+  } finally {
+    cleanup();
+  }
+});
+
+// ─── projectWorktreeToRoot — Module contract ────────────────────────────────
+
+test("projectWorktreeToRoot exists and accepts a MilestoneScope", () => {
+  const projection = new WorktreeStateProjection();
+  assert.equal(typeof projection.projectWorktreeToRoot, "function");
+});
+
+test("projectWorktreeToRoot is non-fatal on same-path scope (project-only mode)", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const workspace = createWorkspace(dir);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    // Same project root on both sides — sync helper fast-paths to no-op.
+    // Module must accept and complete silently.
+    assert.doesNotThrow(() => projection.projectWorktreeToRoot(scope));
+  } finally {
+    cleanup();
+  }
+});
+
+test("projectWorktreeToRoot is idempotent on repeated calls", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const workspace = createWorkspace(dir);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    projection.projectWorktreeToRoot(scope);
+    projection.projectWorktreeToRoot(scope);
+    assert.ok(true, "two calls did not throw");
+  } finally {
+    cleanup();
+  }
+});
+
+// ─── finalizeProjectionForMerge — Module contract ────────────────────────────
+
+test("finalizeProjectionForMerge exists and accepts a MilestoneScope", () => {
+  const projection = new WorktreeStateProjection();
+  assert.equal(typeof projection.finalizeProjectionForMerge, "function");
+});
+
+test("finalizeProjectionForMerge returns { synced } shape on same-path scope", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const workspace = createWorkspace(dir);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    // Project-only mode (no worktreeRoot) — finalize fast-paths to {synced: []}
+    const result = projection.finalizeProjectionForMerge(scope);
+    assert.ok(Array.isArray(result.synced));
+  } finally {
+    cleanup();
+  }
+});