gsd-pi 2.11.0 → 2.13.0

package/src/resources/extensions/gsd/tests/preferences-git.test.ts

@@ -0,0 +1,88 @@
+/**
+ * preferences-git.test.ts — Validates git.isolation and git.merge_to_main preference fields.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+import { validatePreferences } from "../preferences.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  console.log("\n=== git.isolation validation ===");
+
+  // Valid values
+  {
+    const { preferences, errors } = validatePreferences({ git: { isolation: "worktree" } });
+    assertEq(errors.length, 0, "isolation: worktree — no errors");
+    assertEq(preferences.git?.isolation, "worktree", "isolation: worktree — value preserved");
+  }
+  {
+    const { preferences, errors } = validatePreferences({ git: { isolation: "branch" } });
+    assertEq(errors.length, 0, "isolation: branch — no errors");
+    assertEq(preferences.git?.isolation, "branch", "isolation: branch — value preserved");
+  }
+
+  // Invalid values
+  {
+    const { errors } = validatePreferences({ git: { isolation: "invalid" } });
+    assertTrue(errors.length > 0, "isolation: invalid — produces error");
+    assertTrue(errors[0].includes("isolation"), "isolation: invalid — error mentions isolation");
+  }
+  {
+    const { errors } = validatePreferences({ git: { isolation: 42 } });
+    assertTrue(errors.length > 0, "isolation: number — produces error");
+  }
+
+  // Undefined passes through
+  {
+    const { preferences, errors } = validatePreferences({ git: { auto_push: true } });
+    assertEq(errors.length, 0, "isolation: undefined — no errors");
+    assertEq(preferences.git?.isolation, undefined, "isolation: undefined — not set");
+  }
+
+  console.log("\n=== git.merge_to_main validation ===");
+
+  // Valid values
+  {
+    const { preferences, errors } = validatePreferences({ git: { merge_to_main: "milestone" } });
+    assertEq(errors.length, 0, "merge_to_main: milestone — no errors");
+    assertEq(preferences.git?.merge_to_main, "milestone", "merge_to_main: milestone — value preserved");
+  }
+  {
+    const { preferences, errors } = validatePreferences({ git: { merge_to_main: "slice" } });
+    assertEq(errors.length, 0, "merge_to_main: slice — no errors");
+    assertEq(preferences.git?.merge_to_main, "slice", "merge_to_main: slice — value preserved");
+  }
+
+  // Invalid values
+  {
+    const { errors } = validatePreferences({ git: { merge_to_main: "invalid" } });
+    assertTrue(errors.length > 0, "merge_to_main: invalid — produces error");
+    assertTrue(errors[0].includes("merge_to_main"), "merge_to_main: invalid — error mentions merge_to_main");
+  }
+  {
+    const { errors } = validatePreferences({ git: { merge_to_main: false } });
+    assertTrue(errors.length > 0, "merge_to_main: boolean — produces error");
+  }
+
+  // Undefined passes through
+  {
+    const { preferences, errors } = validatePreferences({ git: { auto_push: true } });
+    assertEq(errors.length, 0, "merge_to_main: undefined — no errors");
+    assertEq(preferences.git?.merge_to_main, undefined, "merge_to_main: undefined — not set");
+  }
+
+  console.log("\n=== both fields together ===");
+  {
+    const { preferences, errors } = validatePreferences({
+      git: { isolation: "worktree", merge_to_main: "slice" },
+    });
+    assertEq(errors.length, 0, "both fields valid — no errors");
+    assertEq(preferences.git?.isolation, "worktree", "isolation preserved");
+    assertEq(preferences.git?.merge_to_main, "slice", "merge_to_main preserved");
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/preferences-hooks.test.ts

@@ -0,0 +1,226 @@
+// GSD Extension — Hook Preferences Parsing Tests (Post-Unit + Pre-Dispatch)
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 1: Post-Unit Hook Config Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Post-unit hook config validation ===");
+
+{
+  const validHook = {
+    name: "test-hook",
+    after: ["execute-task"],
+    prompt: "Test prompt",
+    max_cycles: 2,
+    model: "claude-sonnet-4-6",
+    artifact: "TEST-RESULT.md",
+    retry_on: "TEST-ISSUES.md",
+    enabled: true,
+  };
+
+  assertEq(validHook.name, "test-hook", "valid hook has name");
+  assertEq(validHook.after.length, 1, "valid hook has one after entry");
+  assertEq(validHook.after[0], "execute-task", "valid hook triggers after execute-task");
+  assertTrue(validHook.max_cycles! <= 10, "max_cycles within limit");
+  assertTrue(validHook.max_cycles! >= 1, "max_cycles above minimum");
+}
+
+console.log("\n=== max_cycles clamping ===");
+
+{
+  const clampedHigh = Math.max(1, Math.min(10, Math.round(15)));
+  assertEq(clampedHigh, 10, "max_cycles above 10 clamped to 10");
+
+  const clampedLow = Math.max(1, Math.min(10, Math.round(0)));
+  assertEq(clampedLow, 1, "max_cycles below 1 clamped to 1");
+
+  const clampedNeg = Math.max(1, Math.min(10, Math.round(-5)));
+  assertEq(clampedNeg, 1, "negative max_cycles clamped to 1");
+
+  const normal = Math.max(1, Math.min(10, Math.round(3)));
+  assertEq(normal, 3, "normal max_cycles passes through");
+}
+
+console.log("\n=== Post-unit hook merging ===");
+
+{
+  const baseHooks = [
+    { name: "review", after: ["execute-task"], prompt: "base prompt" },
+    { name: "lint", after: ["plan-slice"], prompt: "lint code" },
+  ];
+
+  const overrideHooks = [
+    { name: "review", after: ["execute-task", "complete-slice"], prompt: "override prompt" },
+    { name: "security", after: ["execute-task"], prompt: "security check" },
+  ];
+
+  const merged = [...baseHooks];
+  for (const hook of overrideHooks) {
+    const idx = merged.findIndex(h => h.name === hook.name);
+    if (idx >= 0) {
+      merged[idx] = hook;
+    } else {
+      merged.push(hook);
+    }
+  }
+
+  assertEq(merged.length, 3, "merged has 3 hooks");
+  assertEq(merged[0].prompt, "override prompt", "review hook was overridden");
+  assertEq(merged[0].after.length, 2, "overridden review has 2 after entries");
+  assertEq(merged[1].name, "lint", "lint kept from base");
+  assertEq(merged[2].name, "security", "security added from override");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 2: Pre-Dispatch Hook Config Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Pre-dispatch hook config shape ===");
+
+{
+  const modifyHook = {
+    name: "inject-context",
+    before: ["execute-task"],
+    action: "modify" as const,
+    prepend: "Remember to follow coding conventions.",
+    append: "Run tests after making changes.",
+    enabled: true,
+  };
+
+  assertEq(modifyHook.name, "inject-context", "modify hook has name");
+  assertEq(modifyHook.action, "modify", "action is modify");
+  assertTrue(!!modifyHook.prepend, "has prepend text");
+  assertTrue(!!modifyHook.append, "has append text");
+}
+
+{
+  const skipHook = {
+    name: "skip-research",
+    before: ["research-slice"],
+    action: "skip" as const,
+    skip_if: "RESEARCH-DONE.md",
+    enabled: true,
+  };
+
+  assertEq(skipHook.action, "skip", "action is skip");
+  assertEq(skipHook.skip_if, "RESEARCH-DONE.md", "has skip condition");
+}
+
+{
+  const replaceHook = {
+    name: "custom-planning",
+    before: ["plan-slice"],
+    action: "replace" as const,
+    prompt: "Use custom planning approach for {sliceId}",
+    unit_type: "custom-plan",
+    model: "claude-opus-4-6",
+    enabled: true,
+  };
+
+  assertEq(replaceHook.action, "replace", "action is replace");
+  assertTrue(!!replaceHook.prompt, "replace hook has prompt");
+  assertEq(replaceHook.unit_type, "custom-plan", "has unit_type override");
+}
+
+console.log("\n=== Pre-dispatch action validation ===");
+
+{
+  const validActions = new Set(["modify", "skip", "replace"]);
+  assertTrue(validActions.has("modify"), "modify is valid");
+  assertTrue(validActions.has("skip"), "skip is valid");
+  assertTrue(validActions.has("replace"), "replace is valid");
+  assertTrue(!validActions.has("delete"), "delete is not valid");
+  assertTrue(!validActions.has(""), "empty string is not valid");
+}
+
+console.log("\n=== Pre-dispatch hook merging ===");
+
+{
+  const baseHooks = [
+    { name: "inject", before: ["execute-task"], action: "modify" as const, prepend: "base" },
+  ];
+
+  const overrideHooks = [
+    { name: "inject", before: ["execute-task"], action: "modify" as const, prepend: "override" },
+    { name: "gate", before: ["plan-slice"], action: "skip" as const },
+  ];
+
+  const merged = [...baseHooks];
+  for (const hook of overrideHooks) {
+    const idx = merged.findIndex(h => h.name === hook.name);
+    if (idx >= 0) {
+      merged[idx] = hook;
+    } else {
+      merged.push(hook);
+    }
+  }
+
+  assertEq(merged.length, 2, "merged has 2 pre-dispatch hooks");
+  assertEq(merged[0].prepend, "override", "inject hook overridden");
+  assertEq(merged[1].name, "gate", "gate hook added");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Known unit types validation
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Known unit types ===");
+
+{
+  const knownUnitTypes = new Set([
+    "research-milestone", "plan-milestone", "research-slice", "plan-slice",
+    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
+    "run-uat", "fix-merge", "complete-milestone",
+  ]);
+
+  assertTrue(knownUnitTypes.has("execute-task"), "execute-task is known");
+  assertTrue(knownUnitTypes.has("complete-slice"), "complete-slice is known");
+  assertTrue(knownUnitTypes.has("plan-slice"), "plan-slice is known");
+  assertTrue(!knownUnitTypes.has("hook/review"), "hook types are not in known set");
+  assertTrue(!knownUnitTypes.has("invalid-type"), "invalid types are not in known set");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Preferences YAML format verification
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Preferences YAML format ===");
+
+{
+  const prefsContent = [
+    "---",
+    "version: 1",
+    "post_unit_hooks:",
+    "  - name: code-review",
+    "    after:",
+    "      - execute-task",
+    "    prompt: Review the changes",
+    "    max_cycles: 3",
+    "    artifact: REVIEW-PASS.md",
+    "    retry_on: REVIEW-ISSUES.md",
+    "pre_dispatch_hooks:",
+    "  - name: inject-conventions",
+    "    before:",
+    "      - execute-task",
+    "    action: modify",
+    "    append: Follow project coding conventions",
+    "  - name: custom-research",
+    "    before:",
+    "      - research-slice",
+    "    action: replace",
+    "    prompt: Custom research prompt",
+    "---",
+  ].join("\n");
+
+  assertTrue(prefsContent.includes("post_unit_hooks:"), "has post_unit_hooks key");
+  assertTrue(prefsContent.includes("pre_dispatch_hooks:"), "has pre_dispatch_hooks key");
+  assertTrue(prefsContent.includes("action: modify"), "has modify action");
+  assertTrue(prefsContent.includes("action: replace"), "has replace action");
+}
+
+report();

package/src/resources/extensions/gsd/tests/regex-hardening.test.ts

@@ -67,6 +67,18 @@ async function main(): Promise<void> {
     assertEq('M001-abc123: Title'.replace(TITLE_STRIP_RE, ''), 'Title', 'strips M001-abc123: Title → Title');
     assertEq('M042-z9a8b7: Dashboard'.replace(TITLE_STRIP_RE, ''), 'Dashboard', 'strips M042-z9a8b7: Dashboard');
 
+    // Em dash in title — current format (M001: Title) correctly preserves em dash in title body
+    assertEq(
+      'M001: Foundation — Build Core'.replace(TITLE_STRIP_RE, ''),
+      'Foundation — Build Core',
+      'strips M001: prefix and preserves em dash in title body',
+    );
+    assertEq(
+      'M001-abc123: Foundation — Build Core'.replace(TITLE_STRIP_RE, ''),
+      'Foundation — Build Core',
+      'strips M001-abc123: prefix and preserves em dash in title body (unique format)',
+    );
+
     // Edge case: dash-style separator (M001 — Title: Subtitle preserves colon in body)
     assertEq(
       'M001 — Unique Milestone IDs: Foo'.replace(TITLE_STRIP_RE, ''),

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

@@ -0,0 +1,315 @@
+/**
+ * worktree-e2e.test.ts -- End-to-end tests for worktree-isolated git flow.
+ *
+ * Covers 5 cross-cutting groups not tested by individual slice tests:
+ *   1. Full lifecycle chain (create -> slice commits -> merge to milestone -> merge to main)
+ *   2. Preference gating (shouldUseWorktreeIsolation with overrides)
+ *   3. merge_to_main mode resolution (getMergeToMainMode)
+ *   4. Self-heal in merge context (abortAndReset, withMergeHeal)
+ *   5. Doctor detection of orphaned worktrees
+ */
+
+import {
+  mkdtempSync, mkdirSync, writeFileSync, rmSync,
+  existsSync, realpathSync, readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  mergeMilestoneToMain,
+  mergeSliceToMilestone,
+  shouldUseWorktreeIsolation,
+} from "../auto-worktree.ts";
+import { getSliceBranchName } from "../worktree.ts";
+import { abortAndReset, withMergeHeal, MergeConflictError } from "../git-self-heal.ts";
+import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ---- Helpers ----
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-e2e-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function makeRoadmap(
+  milestoneId: string,
+  title: string,
+  slices: Array<{ id: string; title: string }>,
+): string {
+  const sliceLines = slices.map(s => `- [x] **${s.id}: ${s.title}**`).join("\n");
+  return `# ${milestoneId}: ${title}\n\n## Slices\n${sliceLines}\n`;
+}
+
+function addSliceToMilestone(
+  repo: string,
+  wtPath: string,
+  milestoneId: string,
+  sliceId: string,
+  sliceTitle: string,
+  commits: Array<{ file: string; content: string; message: string }>,
+): void {
+  const normalizedPath = wtPath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  const worktreeName = idx !== -1 ? normalizedPath.slice(idx + marker.length).split("/")[0] : null;
+
+  const sliceBranch = getSliceBranchName(milestoneId, sliceId, worktreeName);
+
+  run(`git checkout -b ${sliceBranch}`, wtPath);
+  for (const c of commits) {
+    writeFileSync(join(wtPath, c.file), c.content);
+    run("git add .", wtPath);
+    run(`git commit -m "${c.message}"`, wtPath);
+  }
+  run(`git checkout milestone/${milestoneId}`, wtPath);
+  mergeSliceToMilestone(repo, milestoneId, sliceId, sliceTitle);
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+  const tempDirs: string[] = [];
+
+  try {
+    // ================================================================
+    // Group 1: Full lifecycle chain
+    // ================================================================
+    console.log("\n=== Full lifecycle: worktree -> slices -> milestone merge -> main ===");
+    {
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Count commits on main before
+      const mainLogBefore = run("git log --oneline main", repo);
+      const commitCountBefore = mainLogBefore.split("\n").length;
+
+      // Create worktree for M001
+      const wtPath = createAutoWorktree(repo, "M001");
+      tempDirs.push(wtPath);
+      assertTrue(existsSync(wtPath), "worktree directory created");
+
+      // Add two slices with commits
+      addSliceToMilestone(repo, wtPath, "M001", "S01", "Add auth", [
+        { file: "auth.ts", content: "export const auth = true;\n", message: "feat: add auth" },
+      ]);
+      addSliceToMilestone(repo, wtPath, "M001", "S02", "Add dashboard", [
+        { file: "dash.ts", content: "export const dash = true;\n", message: "feat: add dashboard" },
+      ]);
+
+      // Build roadmap content
+      const roadmapContent = makeRoadmap("M001", "First milestone", [
+        { id: "S01", title: "Add auth" },
+        { id: "S02", title: "Add dashboard" },
+      ]);
+
+      // Merge milestone to main
+      process.chdir(wtPath);
+      const result = mergeMilestoneToMain(repo, "M001", roadmapContent);
+      process.chdir(savedCwd);
+
+      // Assert exactly one new commit on main
+      const mainLogAfter = run("git log --oneline main", repo);
+      const commitCountAfter = mainLogAfter.split("\n").length;
+      assertEq(commitCountAfter, commitCountBefore + 1, "exactly one new commit on main");
+
+      // Commit message contains both slice titles
+      const lastCommitMsg = run("git log -1 --format=%B main", repo);
+      assertMatch(lastCommitMsg, /Add auth/, "commit message contains S01 title");
+      assertMatch(lastCommitMsg, /Add dashboard/, "commit message contains S02 title");
+
+      // Worktree directory removed
+      assertTrue(!existsSync(wtPath), "worktree directory removed after merge");
+
+      // Milestone branch deleted
+      const branches = run("git branch", repo);
+      assertTrue(!branches.includes("milestone/M001"), "milestone branch deleted");
+    }
+
+    // ================================================================
+    // Group 2: Preference gating (shouldUseWorktreeIsolation)
+    // ================================================================
+    console.log("\n=== Preference gating ===");
+    {
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Override to branch mode
+      const branchResult = shouldUseWorktreeIsolation(repo, { isolation: "branch" });
+      assertEq(branchResult, false, "isolation=branch returns false");
+
+      // Override to worktree mode
+      const wtResult = shouldUseWorktreeIsolation(repo, { isolation: "worktree" });
+      assertEq(wtResult, true, "isolation=worktree returns true");
+
+      // Default (no legacy branches) returns true
+      const defaultResult = shouldUseWorktreeIsolation(repo);
+      assertEq(defaultResult, true, "new project defaults to worktree (true)");
+    }
+
+    // ================================================================
+    // Group 3: merge_to_main mode resolution
+    // ================================================================
+    console.log("\n=== merge_to_main mode ===");
+    {
+      // getMergeToMainMode reads from loadEffectiveGSDPreferences — test via legacy branch detection
+      // Instead, test that the function returns the default "milestone" when no prefs set
+      // (Cannot inject overridePrefs — function signature doesn't accept them)
+      // We verify the shouldUseWorktreeIsolation override path handles legacy detection
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Create a legacy gsd/*/* branch to test legacy detection
+      run("git checkout -b gsd/M001/S01", repo);
+      writeFileSync(join(repo, "legacy.txt"), "legacy\n");
+      run("git add .", repo);
+      run("git commit -m legacy", repo);
+      run("git checkout main", repo);
+
+      const legacyResult = shouldUseWorktreeIsolation(repo);
+      assertEq(legacyResult, false, "legacy gsd branches detected -> branch mode");
+
+      // Explicit worktree override wins over legacy detection
+      const overrideResult = shouldUseWorktreeIsolation(repo, { isolation: "worktree" });
+      assertEq(overrideResult, true, "explicit worktree override wins over legacy");
+    }
+
+    // ================================================================
+    // Group 4: Self-heal (abortAndReset, withMergeHeal)
+    // ================================================================
+    console.log("\n=== Self-heal ===");
+    {
+      // 4a: abortAndReset cleans up MERGE_HEAD
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Create conflicting branches
+      run("git checkout -b feature", repo);
+      writeFileSync(join(repo, "conflict.txt"), "feature content\n");
+      run("git add .", repo);
+      run("git commit -m feature", repo);
+      run("git checkout main", repo);
+      writeFileSync(join(repo, "conflict.txt"), "main content\n");
+      run("git add .", repo);
+      run("git commit -m main-change", repo);
+
+      // Trigger merge conflict
+      try { run("git merge feature", repo); } catch { /* expected */ }
+      assertTrue(existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD exists before abort");
+
+      const abortResult = abortAndReset(repo);
+      assertTrue(!existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after abort");
+      assertTrue(abortResult.cleaned.length > 0, "abortAndReset reports cleaned items");
+    }
+    {
+      // 4b: withMergeHeal throws MergeConflictError for real conflicts
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      run("git checkout -b conflict-branch", repo);
+      writeFileSync(join(repo, "file.txt"), "branch version\n");
+      run("git add .", repo);
+      run("git commit -m branch-ver", repo);
+      run("git checkout main", repo);
+      writeFileSync(join(repo, "file.txt"), "main version\n");
+      run("git add .", repo);
+      run("git commit -m main-ver", repo);
+
+      let caughtError: unknown = null;
+      try {
+        withMergeHeal(repo, () => {
+          execSync("git merge conflict-branch", { cwd: repo, stdio: "pipe" });
+        });
+      } catch (e) {
+        caughtError = e;
+      }
+      assertTrue(caughtError instanceof MergeConflictError, "withMergeHeal throws MergeConflictError");
+      if (caughtError instanceof MergeConflictError) {
+        assertTrue(caughtError.conflictedFiles.length > 0, "MergeConflictError has conflictedFiles");
+      }
+    }
+
+    // ================================================================
+    // Group 5: Doctor detects orphaned worktrees
+    // ================================================================
+    console.log("\n=== Doctor: orphaned worktree detection ===");
+    {
+      // Build a repo with a completed milestone
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Create completed milestone roadmap
+      const msDir = join(repo, ".gsd", "milestones", "M001");
+      mkdirSync(msDir, { recursive: true });
+      writeFileSync(join(msDir, "ROADMAP.md"), `---
+id: M001
+title: "Test Milestone"
+---
+
+# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+      run("git add -A", repo);
+      run("git commit -m 'add milestone'", repo);
+
+      // Create orphaned worktree
+      mkdirSync(join(repo, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", repo);
+
+      // Detect
+      const detect = await runGSDDoctor(repo);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertTrue(orphanIssues.length > 0, "doctor detects orphaned worktree");
+      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+
+      // Fix
+      const fixed = await runGSDDoctor(repo, { fix: true });
+      assertTrue(
+        fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
+        "doctor fix removes orphaned worktree",
+      );
+
+      // Verify gone
+      const wtList = run("git worktree list", repo);
+      assertTrue(!wtList.includes("milestone/M001"), "worktree gone after doctor fix");
+    }
+  } finally {
+    process.chdir(savedCwd);
+    for (const d of tempDirs) {
+      try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  report();
+}
+
+main();