gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

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

@@ -1,38 +1,39 @@
-/**
- * worktree-expected-warnings.test.ts — #3665
- *
- * Verify that auto-worktree.ts and worktree-manager.ts suppress expected
- * ENOENT and EISDIR conditions instead of logging misleading warnings.
- */
+// GSD-2 — Expected worktree condition warning suppression tests.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoWorktreeFile = join(__dirname, "..", "auto-worktree.ts");
-const worktreeManagerFile = join(__dirname, "..", "worktree-manager.ts");
+import { _isExpectedWorktreeUnlinkErrorForTest } from "../auto-worktree.ts";
+import { resolveGitDir } from "../worktree-manager.ts";
 
 describe("worktree expected-condition warning suppression (#3665)", () => {
-  const autoSource = readFileSync(autoWorktreeFile, "utf-8");
-
-  test("auto-worktree.ts checks for ENOENT before logging unlink warning", () => {
-    assert.match(autoSource, /code\s*!==\s*["']ENOENT["']/);
-  });
-
-  test("auto-worktree.ts checks for EISDIR before logging unlink warning", () => {
-    assert.match(autoSource, /code\s*!==\s*["']EISDIR["']/);
+  test("known unlink races are classified as expected", () => {
+    assert.equal(_isExpectedWorktreeUnlinkErrorForTest("ENOENT"), true);
+    assert.equal(_isExpectedWorktreeUnlinkErrorForTest("EISDIR"), true);
+    assert.equal(_isExpectedWorktreeUnlinkErrorForTest("EACCES"), false);
   });
 
-  test("auto-worktree.ts references issue #3597", () => {
-    assert.match(autoSource, /#3597/);
+  test("resolveGitDir returns .git directory without reading it as a file", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-resolve-gitdir-"));
+    try {
+      mkdirSync(join(base, ".git"), { recursive: true });
+      assert.equal(resolveGitDir(base), join(base, ".git"));
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 
-  const managerSource = readFileSync(worktreeManagerFile, "utf-8");
-
-  test("worktree-manager.ts checks isDirectory() before reading .git file", () => {
-    assert.match(managerSource, /lstatSync\(gitPath\)\.isDirectory\(\)/);
+  test("resolveGitDir resolves worktree .git file targets", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-resolve-worktree-gitdir-"));
+    try {
+      mkdirSync(join(base, ".gitdir"), { recursive: true });
+      writeFileSync(join(base, ".git"), "gitdir: .gitdir\n");
+      assert.equal(resolveGitDir(base), resolve(base, ".gitdir"));
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

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

@@ -9,12 +9,13 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readdirSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { PROJECT_FILES } from "../detection.js";
+import { PROJECT_FILES, classifyProject } from "../detection.js";
+import { _shouldProceedWithInvalidRepoClassificationForTest } from "../auto/phases.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -30,6 +31,14 @@ function createGitRepo(): string {
   return dir;
 }
 
+function createEmptyGitRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wt-dispatch-test-empty-"));
+  execSync("git init", { cwd: dir, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: dir, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: dir, stdio: "ignore" });
+  return dir;
+}
+
 /**
  * Simulate the health check logic from auto/phases.ts.
  *
@@ -64,8 +73,6 @@ function hasXcodeBundle(basePath: string): boolean {
   } catch { return false; }
 }
 
-import { existsSync } from "node:fs";
-
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 test("PROJECT_FILES is exported and contains expected multi-ecosystem entries", () => {
@@ -80,6 +87,21 @@ test("PROJECT_FILES is exported and contains expected multi-ecosystem entries",
   assert.ok(PROJECT_FILES.includes("Package.swift"), "includes Swift marker");
 });
 
+test("invalid-repo classification only proceeds when the git marker was already confirmed", () => {
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("missing .git", true),
+    true,
+  );
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("missing .git", false),
+    false,
+  );
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("permission denied", true),
+    false,
+  );
+});
+
 describe("health check with git repo", () => {
   let dir: string;
   beforeEach(() => { dir = createGitRepo(); });
@@ -132,8 +154,18 @@ describe("health check with git repo", () => {
   });
 
   test("health check passes for empty git repo (greenfield project)", () => {
-    assert.ok(wouldPassHealthCheck(dir, existsSync), "empty git repo should pass health check (greenfield)");
-    assert.ok(!hasRecognizedProjectFiles(dir, existsSync), "empty git repo has no recognized project files");
+    const empty = createEmptyGitRepo();
+    try {
+      assert.ok(wouldPassHealthCheck(empty, existsSync), "empty git repo should pass health check (greenfield)");
+      assert.equal(classifyProject(empty).kind, "greenfield");
+    } finally {
+      rmSync(empty, { recursive: true, force: true });
+    }
+  });
+
+  test("health check classifies README-only repo as untyped existing, not greenfield", () => {
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "README-only repo should pass health check");
+    assert.equal(classifyProject(dir).kind, "untyped-existing");
   });
 });
 

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

@@ -39,6 +39,7 @@ function makeDeps(
     getAutoWorktreePath: () => null,
     autoCommitCurrentBranch: () => {},
     getCurrentBranch: () => "main",
+    checkoutBranch: () => {},
     autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
     resolveMilestoneFile: (_basePath: string, milestoneId: string) =>
       `/project/.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md`,

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 { _resolveAutoWorktreeStartPointForTest } from "../auto-worktree.ts";
+
+test("auto-worktree start point prefers milestone integration branch", () => {
+  const startPoint = _resolveAutoWorktreeStartPointForTest(
+    "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(
+    _resolveAutoWorktreeStartPointForTest(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(
+    _resolveAutoWorktreeStartPointForTest(null, "stale", () => false),
+    undefined,
   );
 });

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

@@ -235,4 +235,11 @@ describe("removeWorktree — missing worktree", () => {
       "should not throw when worktree does not exist",
     );
   });
+
+  test("deleteBranch is quiet when the branch is already gone", () => {
+    assert.doesNotThrow(
+      () => removeWorktree(base, "nonexistent", { deleteBranch: true }),
+      "missing branch should be treated as already cleaned up",
+    );
+  });
 });

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

@@ -56,11 +56,11 @@ test("#2616: findNestedGitDirs ignores .git files (worktree pointers)", (t) => {
   );
 });
 
-test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, target)", (t) => {
+test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, .bg-shell, target)", (t) => {
   const root = makeRoot(t);
 
   // All three of these contain a .git *directory*, but the scan must skip them.
-  for (const excluded of ["node_modules", ".gsd", "target"]) {
+  for (const excluded of ["node_modules", ".gsd", ".bg-shell", "target"]) {
     const inside = join(root, excluded, "vendored-pkg");
     mkdirSync(join(inside, ".git"), { recursive: true });
   }
@@ -73,6 +73,13 @@ test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, t
   );
 });
 
+test("#2616: findNestedGitDirs ignores normal missing child .git probes", (t) => {
+  const root = makeRoot(t);
+  mkdirSync(join(root, "plain-dir"), { recursive: true });
+
+  assert.deepEqual(findNestedGitDirs(root), []);
+});
+
 test("#2616: findNestedGitDirs finds deeply nested repos", (t) => {
   const root = makeRoot(t);
   const deep = join(root, "a", "b", "c", "scaffolded");

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