gsd-pi 2.12.0 → 2.13.0

package/dist/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -0,0 +1,259 @@
+/**
+ * auto-worktree-milestone-merge.test.ts — Integration tests for mergeMilestoneToMain.
+ *
+ * Covers: squash-merge topology (one commit on main), rich commit message with
+ * slice titles, worktree cleanup, nothing-to-commit edge case, auto-push with
+ * bare remote. All tests use real git operations in temp repos.
+ */
+
+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,
+  getAutoWorktreeOriginalBase,
+} from "../auto-worktree.ts";
+import { getSliceBranchName } from "../worktree.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+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-ms-merge-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;
+}
+
+/** Minimal roadmap content for mergeMilestoneToMain. */
+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`;
+}
+
+/** Set up a slice branch on the worktree, add commits, merge it --no-ff to milestone. */
+function addSliceToMilestone(
+  repo: string,
+  wtPath: string,
+  milestoneId: string,
+  sliceId: string,
+  sliceTitle: string,
+  commits: Array<{ file: string; content: string; message: string }>,
+): void {
+  // Detect worktree name for branch naming
+  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[] = [];
+
+  function freshRepo(): string {
+    const d = createTempRepo();
+    tempDirs.push(d);
+    return d;
+  }
+
+  try {
+    // ─── Test 1: Basic squash merge — one commit on main ───────────────
+    console.log("\n=== basic squash merge — one commit on main ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M010");
+
+      // Add two slices with multiple commits each
+      addSliceToMilestone(repo, wtPath, "M010", "S01", "Auth module", [
+        { file: "auth.ts", content: "export const auth = true;\n", message: "add auth" },
+        { file: "auth-utils.ts", content: "export const hash = () => {};\n", message: "add auth utils" },
+      ]);
+      addSliceToMilestone(repo, wtPath, "M010", "S02", "User dashboard", [
+        { file: "dashboard.ts", content: "export const dash = true;\n", message: "add dashboard" },
+        { file: "widgets.ts", content: "export const widgets = [];\n", message: "add widgets" },
+      ]);
+
+      const roadmap = makeRoadmap("M010", "User management", [
+        { id: "S01", title: "Auth module" },
+        { id: "S02", title: "User dashboard" },
+      ]);
+
+      const mainLogBefore = run("git log --oneline main", repo);
+      const mainCommitCountBefore = mainLogBefore.split("\n").length;
+
+      const result = mergeMilestoneToMain(repo, "M010", roadmap);
+
+      // Exactly one new commit on main
+      const mainLog = run("git log --oneline main", repo);
+      const mainCommitCountAfter = mainLog.split("\n").length;
+      assertEq(mainCommitCountAfter, mainCommitCountBefore + 1, "exactly one new commit on main");
+
+      // Milestone branch deleted
+      const branches = run("git branch", repo);
+      assertTrue(!branches.includes("milestone/M010"), "milestone branch deleted");
+
+      // Worktree directory removed
+      const worktreeDir = join(repo, ".gsd", "worktrees", "M010");
+      assertTrue(!existsSync(worktreeDir), "worktree directory removed");
+
+      // Module state cleared
+      assertEq(getAutoWorktreeOriginalBase(), null, "originalBase cleared after merge");
+
+      // Files from both slices present on main
+      assertTrue(existsSync(join(repo, "auth.ts")), "auth.ts on main");
+      assertTrue(existsSync(join(repo, "dashboard.ts")), "dashboard.ts on main");
+      assertTrue(existsSync(join(repo, "widgets.ts")), "widgets.ts on main");
+
+      // Result shape
+      assertTrue(result.commitMessage.length > 0, "commitMessage returned");
+      assertTrue(typeof result.pushed === "boolean", "pushed is boolean");
+    }
+
+    // ─── Test 2: Rich commit message format ────────────────────────────
+    console.log("\n=== rich commit message format ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M020");
+
+      addSliceToMilestone(repo, wtPath, "M020", "S01", "Core API", [
+        { file: "api.ts", content: "export const api = true;\n", message: "add api" },
+      ]);
+      addSliceToMilestone(repo, wtPath, "M020", "S02", "Error handling", [
+        { file: "errors.ts", content: "export class AppError {}\n", message: "add errors" },
+      ]);
+      addSliceToMilestone(repo, wtPath, "M020", "S03", "Logging infra", [
+        { file: "logger.ts", content: "export const log = () => {};\n", message: "add logger" },
+      ]);
+
+      const roadmap = makeRoadmap("M020", "Backend foundation", [
+        { id: "S01", title: "Core API" },
+        { id: "S02", title: "Error handling" },
+        { id: "S03", title: "Logging infra" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M020", roadmap);
+
+      // Subject line: conventional commit format
+      assertMatch(result.commitMessage, /^feat\(M020\):/, "subject has conventional commit prefix");
+      assertTrue(result.commitMessage.includes("Backend foundation"), "subject includes milestone title");
+
+      // Body: slice listing
+      assertTrue(result.commitMessage.includes("- S01: Core API"), "body lists S01");
+      assertTrue(result.commitMessage.includes("- S02: Error handling"), "body lists S02");
+      assertTrue(result.commitMessage.includes("- S03: Logging infra"), "body lists S03");
+
+      // Branch metadata
+      assertTrue(result.commitMessage.includes("Branch: milestone/M020"), "body has branch metadata");
+
+      // Verify the actual git commit message matches
+      const gitMsg = run("git log -1 --format=%B main", repo).trim();
+      assertMatch(gitMsg, /^feat\(M020\):/, "git commit message starts with feat(M020):");
+      assertTrue(gitMsg.includes("- S01: Core API"), "git commit body has S01");
+    }
+
+    // ─── Test 3: Nothing to commit — no changes ────────────────────────
+    console.log("\n=== nothing to commit — no changes ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M030");
+
+      // Don't add any slices/changes — milestone branch is identical to main
+      const roadmap = makeRoadmap("M030", "Empty milestone", []);
+
+      // Should complete without throwing
+      let threw = false;
+      try {
+        const result = mergeMilestoneToMain(repo, "M030", roadmap);
+        assertTrue(typeof result.pushed === "boolean", "returns result even with nothing to commit");
+      } catch {
+        threw = true;
+      }
+      assertTrue(!threw, "does not throw on nothing-to-commit");
+
+      // Main log unchanged (only init commit)
+      const mainLog = run("git log --oneline main", repo);
+      assertEq(mainLog.split("\n").length, 1, "main still has only init commit");
+    }
+
+    // ─── Test 4: Auto-push — verify push mechanics work ──────────────
+    // Note: loadEffectiveGSDPreferences uses a module-level const for project
+    // prefs path (process.cwd() at import time), so temp repo prefs aren't
+    // discoverable. We verify the push mechanics work by testing that
+    // mergeMilestoneToMain successfully completes with a remote configured,
+    // then manually push to verify the remote is set up correctly.
+    console.log("\n=== auto-push with bare remote ===");
+    {
+      const repo = freshRepo();
+
+      // Set up bare remote
+      const bareDir = realpathSync(mkdtempSync(join(tmpdir(), "wt-ms-bare-")));
+      tempDirs.push(bareDir);
+      run("git init --bare", bareDir);
+      run(`git remote add origin ${bareDir}`, repo);
+      run("git push -u origin main", repo);
+
+      const wtPath = createAutoWorktree(repo, "M040");
+
+      addSliceToMilestone(repo, wtPath, "M040", "S01", "Push test", [
+        { file: "pushed.ts", content: "export const pushed = true;\n", message: "add pushed file" },
+      ]);
+
+      const roadmap = makeRoadmap("M040", "Push verification", [
+        { id: "S01", title: "Push test" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M040", roadmap);
+
+      // Verify merge succeeded (commit on main)
+      const mainLog = run("git log --oneline main", repo);
+      assertTrue(mainLog.includes("feat(M040)"), "milestone commit on main");
+
+      // Manually push to verify remote works
+      run("git push origin main", repo);
+      const remoteLog = run("git log --oneline main", bareDir);
+      assertTrue(remoteLog.includes("feat(M040)"), "milestone commit reachable on remote after manual push");
+
+      // result.pushed will be false since prefs aren't loadable in temp repos
+      // (module-level const limitation) — that's expected
+      assertEq(result.pushed, false, "pushed is false without discoverable prefs");
+    }
+
+  } finally {
+    process.chdir(savedCwd);
+    for (const d of tempDirs) {
+      if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+    }
+  }
+
+  report();
+}
+
+main();

package/dist/resources/extensions/gsd/tests/auto-worktree.test.ts

@@ -0,0 +1,147 @@
+/**
+ * auto-worktree.test.ts — Tests for auto-worktree lifecycle.
+ *
+ * Covers: create → detect → teardown, re-entry, path helpers.
+ * Runs in a real temp git repo.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  teardownAutoWorktree,
+  isInAutoWorktree,
+  getAutoWorktreePath,
+  enterAutoWorktree,
+  getAutoWorktreeOriginalBase,
+} from "../auto-worktree.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "auto-wt-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  // Create initial commit on main
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  // Ensure branch is called main
+  run("git branch -M main", dir);
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Create .gsd/milestones/M003 with a dummy file (simulates planning artifacts)
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m 'add milestone'", tempDir);
+
+    console.log("\n=== auto-worktree lifecycle ===");
+
+    // ─── createAutoWorktree ──────────────────────────────────────────
+    const wtPath = createAutoWorktree(tempDir, "M003");
+
+    assertTrue(existsSync(wtPath), "worktree directory exists after create");
+    assertEq(process.cwd(), wtPath, "process.cwd() is worktree path after create");
+
+    const branch = run("git branch --show-current", wtPath);
+    assertEq(branch, "milestone/M003", "git branch is milestone/M003");
+
+    assertTrue(
+      existsSync(join(wtPath, ".gsd", "milestones", "M003", "CONTEXT.md")),
+      "planning files inherited in worktree",
+    );
+
+    // ─── isInAutoWorktree ────────────────────────────────────────────
+    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree returns true when inside");
+
+    // ─── getAutoWorktreeOriginalBase ─────────────────────────────────
+    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
+
+    // ─── getAutoWorktreePath ─────────────────────────────────────────
+    assertEq(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
+    assertEq(getAutoWorktreePath(tempDir, "M999"), null, "getAutoWorktreePath returns null for nonexistent");
+
+    // ─── teardownAutoWorktree ────────────────────────────────────────
+    teardownAutoWorktree(tempDir, "M003");
+
+    assertEq(process.cwd(), tempDir, "process.cwd() back to original after teardown");
+    assertTrue(!existsSync(wtPath), "worktree directory removed after teardown");
+    assertTrue(!isInAutoWorktree(tempDir), "isInAutoWorktree returns false after teardown");
+    assertEq(getAutoWorktreeOriginalBase(), null, "originalBase is null after teardown");
+
+    // ─── Re-entry: create again, exit without teardown, re-enter ─────
+    console.log("\n=== re-entry ===");
+
+    const wtPath2 = createAutoWorktree(tempDir, "M003");
+    assertTrue(existsSync(wtPath2), "worktree re-created");
+
+    // Manually chdir out (simulates pause/crash)
+    process.chdir(tempDir);
+
+    // enterAutoWorktree should re-enter
+    const entered = enterAutoWorktree(tempDir, "M003");
+    assertEq(process.cwd(), entered, "re-entered worktree via enterAutoWorktree");
+    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase restored on re-entry");
+    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree true after re-entry");
+
+    // Cleanup
+    teardownAutoWorktree(tempDir, "M003");
+
+    // ─── Coexistence with manual worktree ─────────────────────────────
+    console.log("\n=== coexistence ===");
+
+    // Import createWorktree directly for manual worktree
+    const { createWorktree } = await import("../worktree-manager.ts");
+
+    // Create manual worktree (uses worktree/<name> branch)
+    const manualWt = createWorktree(tempDir, "feature-x");
+    assertTrue(existsSync(manualWt.path), "manual worktree exists");
+    assertEq(manualWt.branch, "worktree/feature-x", "manual worktree uses worktree/ prefix");
+
+    // Create auto-worktree alongside
+    const autoWtPath = createAutoWorktree(tempDir, "M003");
+    assertTrue(existsSync(autoWtPath), "auto-worktree coexists with manual");
+    assertTrue(existsSync(manualWt.path), "manual worktree still exists");
+
+    // Cleanup both
+    teardownAutoWorktree(tempDir, "M003");
+    const { removeWorktree } = await import("../worktree-manager.ts");
+    removeWorktree(tempDir, "feature-x");
+
+    // ─── Failure: split-brain prevention ──────────────────────────────
+    console.log("\n=== split-brain prevention ===");
+    // After teardown, originalBase should be null
+    assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
+
+  } finally {
+    // Always restore cwd and clean up
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  report("auto-worktree");
+}
+
+main();

package/dist/resources/extensions/gsd/tests/doctor-git.test.ts

@@ -0,0 +1,246 @@
+/**
+ * doctor-git.test.ts — Integration tests for doctor git health checks.
+ *
+ * Creates real temp git repos with deliberate broken state, runs runGSDDoctor,
+ * and asserts correct detection and fixing of all 4 git issue codes:
+ *   orphaned_auto_worktree, stale_milestone_branch,
+ *   corrupt_merge_state, tracked_runtime_files
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with a completed milestone M001 in roadmap. */
+function createRepoWithCompletedMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  // Initial commit
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  // Create .gsd structure with milestone M001 — all slices done → complete
+  const msDir = join(dir, ".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_
+`);
+
+  // Commit .gsd files
+  run("git add -A", dir);
+  run("git commit -m 'add milestone'", dir);
+
+  return dir;
+}
+
+/** Create a repo with an in-progress milestone. */
+function createRepoWithActiveMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-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");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const msDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "ROADMAP.md"), `---
+id: M001
+title: "Active Milestone"
+---
+
+# M001: Active Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [ ] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+
+  run("git add -A", dir);
+  run("git commit -m 'add milestone'", dir);
+
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const cleanups: string[] = [];
+
+  try {
+    // ─── Test 1: Orphaned worktree detection & fix ─────────────────────
+    console.log("\n=== orphaned_auto_worktree ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create worktree with milestone/M001 branch under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertTrue(orphanIssues.length > 0, "detects orphaned worktree");
+      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")), "fix removes orphaned worktree");
+
+      // Verify worktree is gone
+      const wtList = run("git worktree list", dir);
+      assertTrue(!wtList.includes("milestone/M001"), "worktree no longer listed after fix");
+    }
+
+    // ─── Test 2: Stale milestone branch detection & fix ────────────────
+    console.log("\n=== stale_milestone_branch ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create a milestone/M001 branch (no worktree)
+      run("git branch milestone/M001", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_milestone_branch");
+      assertTrue(staleIssues.length > 0, "detects stale milestone branch");
+      assertEq(staleIssues[0]?.unitId, "M001", "stale branch unitId is M001");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("deleted stale branch")), "fix deletes stale branch");
+
+      // Verify branch is gone
+      const branches = run("git branch --list 'milestone/*'", dir);
+      assertTrue(!branches.includes("milestone/M001"), "branch gone after fix");
+    }
+
+    // ─── Test 3: Corrupt merge state detection & fix ───────────────────
+    console.log("\n=== corrupt_merge_state ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Inject MERGE_HEAD into .git
+      const headHash = run("git rev-parse HEAD", dir);
+      writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
+
+      const detect = await runGSDDoctor(dir);
+      const mergeIssues = detect.issues.filter(i => i.code === "corrupt_merge_state");
+      assertTrue(mergeIssues.length > 0, "detects corrupt merge state");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("cleaned merge state")), "fix cleans merge state");
+
+      // Verify MERGE_HEAD is gone
+      assertTrue(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after fix");
+    }
+
+    // ─── Test 4: Tracked runtime files detection & fix ─────────────────
+    console.log("\n=== tracked_runtime_files ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Force-add a runtime file
+      const activityDir = join(dir, ".gsd", "activity");
+      mkdirSync(activityDir, { recursive: true });
+      writeFileSync(join(activityDir, "test.log"), "log data\n");
+      run("git add -f .gsd/activity/test.log", dir);
+      run("git commit -m 'track runtime file'", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const trackedIssues = detect.issues.filter(i => i.code === "tracked_runtime_files");
+      assertTrue(trackedIssues.length > 0, "detects tracked runtime files");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("untracked")), "fix untracks runtime files");
+
+      // Verify file is no longer tracked
+      const tracked = run("git ls-files .gsd/activity/", dir);
+      assertEq(tracked, "", "runtime file untracked after fix");
+    }
+
+    // ─── Test 5: Non-git directory — graceful degradation ──────────────
+    console.log("\n=== non-git directory ===");
+    {
+      const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
+      cleanups.push(dir);
+
+      // Create minimal .gsd structure (no git)
+      mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+      const result = await runGSDDoctor(dir);
+      const gitIssues = result.issues.filter(i =>
+        ["orphaned_auto_worktree", "stale_milestone_branch", "corrupt_merge_state", "tracked_runtime_files"].includes(i.code)
+      );
+      assertEq(gitIssues.length, 0, "no git issues in non-git directory");
+      // Should not throw — reaching here means no crash
+      assertTrue(true, "non-git directory does not crash");
+    }
+
+    // ─── Test 6: Active worktree NOT flagged (false positive prevention) ─
+    console.log("\n=== active worktree safety ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create worktree for in-progress milestone under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertEq(orphanIssues.length, 0, "active worktree NOT flagged as orphaned");
+    }
+
+  } finally {
+    for (const dir of cleanups) {
+      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  report();
+}
+
+main();