gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

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

@@ -4,58 +4,92 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
 
-test("dispatch guard blocks when prior milestone has incomplete slices", () => {
+/** Helper: create temp dir and open an in-dir DB for dispatch-guard tests */
+function setupRepo(): string {
   const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  openDatabase(join(repo, ".gsd", "gsd.db"));
+  return repo;
+}
+
+/** Helper: tear down repo (close DB then remove dir) */
+function teardownRepo(repo: string): void {
+  closeDatabase();
+  rmSync(repo, { recursive: true, force: true });
+}
+
+test("dispatch guard blocks when prior milestone has incomplete slices", () => {
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
     mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
 
-    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "# M002: Previous\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [ ] **S02: Pending** `risk:low` `depends:[S01]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Current\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
+    // Seed DB: M002 with S01 complete, S02 pending
+    insertMilestone({ id: "M002", title: "Previous" });
+    insertSlice({ id: "S01", milestoneId: "M002", title: "Done", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M002", title: "Pending", status: "pending", depends: ["S01"], sequence: 2 });
+
+    // M003 with two pending slices
+    insertMilestone({ id: "M003", title: "Current" });
+    insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M003", title: "Second", status: "pending", depends: ["S01"], sequence: 2 });
+
+    // Need ROADMAP files for milestone discovery (findMilestoneIds reads disk)
+    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
 
     assert.equal(
       getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
       "Cannot dispatch plan-slice M003/S01: earlier slice M002/S02 is not complete.",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
 test("dispatch guard blocks later slice in same milestone when earlier incomplete", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
     mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
 
-    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "# M002: Previous\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [x] **S02: Done** `risk:low` `depends:[S01]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Current\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
+    insertMilestone({ id: "M002", title: "Previous" });
+    insertSlice({ id: "S01", milestoneId: "M002", title: "Done", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M002", title: "Done", status: "complete", depends: ["S01"], sequence: 2 });
+
+    insertMilestone({ id: "M003", title: "Current" });
+    insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M003", title: "Second", status: "pending", depends: ["S01"], sequence: 2 });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
 
     assert.equal(
       getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
       "Cannot dispatch execute-task M003/S02/T01: dependency slice M003/S01 is not complete.",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
 test("dispatch guard allows dispatch when all earlier slices complete", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Current\n\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
+
+    insertMilestone({ id: "M003", title: "Current" });
+    insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M003", title: "Second", status: "pending", depends: ["S01"], sequence: 2 });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
 
     assert.equal(getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"), null);
     assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-milestone", "M003"), null);
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
@@ -63,17 +97,19 @@ test("dispatch guard unblocks slice when positionally-earlier slice depends on i
   // S05 depends on S06, but S05 appears first positionally.
   // Old behavior: S06 blocked because S05 (positionally earlier) is incomplete.
   // Fixed behavior: S06 has no unmet dependencies, so it can dispatch.
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n" +
-      "- [x] **S01: Setup** `risk:low` `depends:[]`\n" +
-      "- [x] **S02: Core** `risk:low` `depends:[S01]`\n" +
-      "- [x] **S03: API** `risk:low` `depends:[S02]`\n" +
-      "- [x] **S04: Auth** `risk:low` `depends:[S03]`\n" +
-      "- [ ] **S05: Integration** `risk:high` `depends:[S04,S06]`\n" +
-      "- [ ] **S06: Data Layer** `risk:medium` `depends:[S04]`\n");
+
+    insertMilestone({ id: "M001", title: "Test" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Setup", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Core", status: "complete", depends: ["S01"], sequence: 2 });
+    insertSlice({ id: "S03", milestoneId: "M001", title: "API", status: "complete", depends: ["S02"], sequence: 3 });
+    insertSlice({ id: "S04", milestoneId: "M001", title: "Auth", status: "complete", depends: ["S03"], sequence: 4 });
+    insertSlice({ id: "S05", milestoneId: "M001", title: "Integration", status: "pending", depends: ["S04", "S06"], sequence: 5 });
+    insertSlice({ id: "S06", milestoneId: "M001", title: "Data Layer", status: "pending", depends: ["S04"], sequence: 6 });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
 
     // S06 depends only on S04 (complete) — should be unblocked
     assert.equal(
@@ -87,19 +123,21 @@ test("dispatch guard unblocks slice when positionally-earlier slice depends on i
       "Cannot dispatch plan-slice M001/S05: dependency slice M001/S06 is not complete.",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
 test("dispatch guard falls back to positional ordering when no dependencies declared", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n" +
-      "- [x] **S01: First** `risk:low` `depends:[]`\n" +
-      "- [ ] **S02: Second** `risk:low` `depends:[]`\n" +
-      "- [ ] **S03: Third** `risk:low` `depends:[]`\n");
+
+    insertMilestone({ id: "M001", title: "Test" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending", depends: [], sequence: 2 });
+    insertSlice({ id: "S03", milestoneId: "M001", title: "Third", status: "pending", depends: [], sequence: 3 });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
 
     // S03 has no dependencies — positional fallback blocks on S02
     assert.equal(
@@ -113,20 +151,22 @@ test("dispatch guard falls back to positional ordering when no dependencies decl
       null,
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
 test("dispatch guard allows slice with all declared dependencies complete", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n" +
-      "- [x] **S01: Setup** `risk:low` `depends:[]`\n" +
-      "- [x] **S02: Core** `risk:low` `depends:[S01]`\n" +
-      "- [ ] **S03: Feature A** `risk:low` `depends:[S01,S02]`\n" +
-      "- [ ] **S04: Feature B** `risk:low` `depends:[S01]`\n");
+
+    insertMilestone({ id: "M001", title: "Test" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Setup", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Core", status: "complete", depends: ["S01"], sequence: 2 });
+    insertSlice({ id: "S03", milestoneId: "M001", title: "Feature A", status: "pending", depends: ["S01", "S02"], sequence: 3 });
+    insertSlice({ id: "S04", milestoneId: "M001", title: "Feature B", status: "pending", depends: ["S01"], sequence: 4 });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
 
     // S03 depends on S01 (done) and S02 (done) — unblocked
     assert.equal(
@@ -140,28 +180,31 @@ test("dispatch guard allows slice with all declared dependencies complete", () =
       null,
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
 test("dispatch guard skips completed milestone with SUMMARY even if it has unchecked remediation slices (#1716)", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
     mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
 
-    // M001 is complete (has SUMMARY) but has unchecked remediation slices
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Previous\n\n## Slices\n" +
-      "- [x] **S01: Core** `risk:low` `depends:[]`\n" +
-      "- [x] **S02: Tests** `risk:low` `depends:[S01]`\n" +
-      "- [ ] **S03-R: Remediation** `risk:low` `depends:[S02]`\n" +
-      "- [ ] **S04-R: Remediation 2** `risk:low` `depends:[S02]`\n");
+    // M001 is complete (has SUMMARY) but has unchecked remediation slices in DB
+    insertMilestone({ id: "M001", title: "Previous" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Core", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Tests", status: "complete", depends: ["S01"], sequence: 2 });
+    insertSlice({ id: "S03-R", milestoneId: "M001", title: "Remediation", status: "pending", depends: ["S02"], sequence: 3 });
+    insertSlice({ id: "S04-R", milestoneId: "M001", title: "Remediation 2", status: "pending", depends: ["S02"], sequence: 4 });
+
+    insertMilestone({ id: "M002", title: "Current" });
+    insertSlice({ id: "S01", milestoneId: "M002", title: "Start", status: "pending", depends: [], sequence: 1 });
+
+    // M001 SUMMARY on disk triggers skip
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
     writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
       "---\nstatus: complete\n---\n# M001 Summary\nDone.\n");
-
-    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "# M002: Current\n\n## Slices\n- [ ] **S01: Start** `risk:low` `depends:[]`\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
 
     // M001 has SUMMARY — should be skipped, not block M002/S01
     assert.equal(
@@ -169,19 +212,23 @@ test("dispatch guard skips completed milestone with SUMMARY even if it has unche
       null,
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });
 
 test("dispatch guard works without git repo", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-nogit-"));
+  const repo = setupRepo();
   try {
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [ ] **S02: Pending** `risk:low` `depends:[S01]`\n");
+
+    insertMilestone({ id: "M001", title: "Test" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Done", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Pending", status: "pending", depends: ["S01"], sequence: 2 });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
 
     assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"), null);
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    teardownRepo(repo);
   }
 });

package/src/resources/extensions/gsd/tests/doctor-completion-deferral.test.ts

@@ -1,20 +1,16 @@
 /**
- * Regression test for #1808: Completion-transition doctor fix deferral
- * creates fragile handoff window.
+ * Regression test for #1808: Completion-transition doctor fix deferral.
  *
- * Only slice summary should be deferred (needs LLM content).
- * Roadmap checkbox and UAT stub are mechanical bookkeeping and must be
- * fixed immediately at task fixLevel to prevent inconsistent state if the
- * session stops between last task and complete-slice.
+ * Reconciliation codes are removed — doctor no longer creates summary/UAT
+ * stubs or reports checkbox/file mismatch issues.
  */
 
-import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
 import { runGSDDoctor } from "../doctor.ts";
-import { COMPLETION_TRANSITION_CODES } from "../doctor-types.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-deferral-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -22,11 +18,6 @@ function makeTmp(name: string): string {
   return dir;
 }
 
-/**
- * Build a minimal .gsd structure: milestone with one slice, one task
- * marked done with a summary — but no slice summary, no UAT, and
- * roadmap unchecked. This is the state after the last task completes.
- */
 function buildScaffold(base: string) {
   const gsd = join(base, ".gsd");
   const m = join(gsd, "milestones", "M001");
@@ -65,83 +56,34 @@ Done.
 `);
 }
 
-test("COMPLETION_TRANSITION_CODES only contains slice summary code", () => {
-  assert.ok(
-    COMPLETION_TRANSITION_CODES.has("all_tasks_done_missing_slice_summary"),
-    "summary code should still be deferred"
-  );
-  assert.ok(
-    !COMPLETION_TRANSITION_CODES.has("all_tasks_done_missing_slice_uat"),
-    "UAT code should NOT be deferred"
-  );
-  assert.ok(
-    !COMPLETION_TRANSITION_CODES.has("all_tasks_done_roadmap_not_checked"),
-    "roadmap code should NOT be deferred"
-  );
-});
-
-test("fixLevel:task — fixes UAT stub immediately, defers summary and roadmap checkbox (#1808, #1910)", async () => {
-  const tmp = makeTmp("partial-deferral");
+test("doctor does not report any reconciliation issue codes", async () => {
+  const tmp = makeTmp("no-reconciliation");
   try {
     buildScaffold(tmp);
 
     const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
 
-    // Should detect all three issues
+    const REMOVED_CODES = [
+      "task_done_missing_summary",
+      "task_summary_without_done_checkbox",
+      "all_tasks_done_missing_slice_summary",
+      "all_tasks_done_missing_slice_uat",
+      "all_tasks_done_roadmap_not_checked",
+      "slice_checked_missing_summary",
+      "slice_checked_missing_uat",
+    ];
+
     const codes = report.issues.map(i => i.code);
-    assert.ok(codes.includes("all_tasks_done_missing_slice_summary"), "should detect missing summary");
-    assert.ok(codes.includes("all_tasks_done_missing_slice_uat"), "should detect missing UAT");
-    assert.ok(codes.includes("all_tasks_done_roadmap_not_checked"), "should detect unchecked roadmap");
+    for (const removed of REMOVED_CODES) {
+      assert.ok(!codes.includes(removed as any), `should NOT report removed code: ${removed}`);
+    }
 
-    // Summary should NOT be created (still deferred — needs LLM content)
+    // No summary or UAT stubs should be created
     const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub (deferred)");
+    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
 
-    // UAT stub SHOULD be created (mechanical bookkeeping, no longer deferred)
     const sliceUatPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
-    assert.ok(existsSync(sliceUatPath), "should have created UAT stub immediately");
-
-    // Roadmap checkbox must NOT be checked without summary on disk (#1910).
-    // Checking it without the summary causes deriveState() to skip complete-slice.
-    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap must NOT be checked without summary on disk (#1910)");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("fixLevel:task — session crash after last task leaves UAT consistent, roadmap deferred with summary (#1808, #1910)", async () => {
-  const tmp = makeTmp("crash-consistency");
-  try {
-    buildScaffold(tmp);
-
-    // Simulate: doctor runs at task level (as auto-mode does after last task)
-    await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    // Now simulate a session crash — no complete-slice ever runs.
-    // A new session starts and runs doctor again at task level.
-    const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    const remainingCodes = report2.issues.map(i => i.code);
-    assert.ok(
-      !remainingCodes.includes("all_tasks_done_missing_slice_uat"),
-      "UAT should already be fixed from first doctor run"
-    );
-    // Summary is still missing (deferred), that is expected
-    assert.ok(
-      remainingCodes.includes("all_tasks_done_missing_slice_summary"),
-      "summary should still be detected as missing (deferred)"
-    );
-    // Roadmap should still be unchecked because summary doesn't exist (#1910)
-    assert.ok(
-      remainingCodes.includes("all_tasks_done_roadmap_not_checked"),
-      "roadmap should still be unchecked — summary does not exist on disk (#1910)"
-    );
-    // Must NOT produce the cascade error from checking roadmap without summary
-    assert.ok(
-      !remainingCodes.includes("slice_checked_missing_summary"),
-      "must not produce slice_checked_missing_summary (#1910)"
-    );
+    assert.ok(!existsSync(sliceUatPath), "should NOT have created UAT stub");
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/doctor-enhancements.test.ts

@@ -204,15 +204,13 @@ async function main(): Promise<void> {
   {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Dry Run Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
-    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
 
     const result = await runGSDDoctor(base, { fix: true, dryRun: true });
-    // In dry-run mode, no actual files should be created
-    assertTrue(!existsSync(join(sDir, "S01-SUMMARY.md")), "dry-run does not create slice summary");
-    assertTrue(
-      result.fixesApplied.some(f => f.startsWith("[dry-run]")),
-      "dry-run mode reports would-fix entries",
-    );
+    // dry-run with fix:true still runs the doctor; shouldFix() returns false
+    // so no reconciliation fixes are applied through that path
+    assertTrue(result.issues !== undefined, "dry-run still produces issue list");
+    assertTrue(Array.isArray(result.fixesApplied), "dry-run report has fixesApplied array");
 
     rmSync(base, { recursive: true, force: true });
   }

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

@@ -0,0 +1,175 @@
+/**
+ * doctor-environment-worktree.test.ts — Worktree-aware dependency checks (#2303).
+ *
+ * Reproduction: doctor-environment `checkDependenciesInstalled` falsely reports
+ * `env_dependencies` error inside auto-worktrees because `node_modules` is
+ * absent by design (worktrees symlink to the project root's node_modules and
+ * the symlink may not yet exist at check time).
+ *
+ * Fix: when the basePath contains `.gsd/worktrees/`, resolve the project root
+ * and check its node_modules instead.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, symlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  runEnvironmentChecks,
+  environmentResultsToDoctorIssues,
+  checkEnvironmentHealth,
+} from "../doctor-environment.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+/** Create a directory tree with files. */
+function createDir(files: Record<string, string> = {}): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-wt-env-"));
+  for (const [name, content] of Object.entries(files)) {
+    const filePath = join(dir, name);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content);
+  }
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const cleanups: string[] = [];
+
+  try {
+    // ── Reproduction: worktree path without node_modules ───────────────
+    console.log("\n=== worktree: missing node_modules should NOT error when project root has them ===");
+    {
+      // Simulate project root with node_modules
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      mkdirSync(join(projectRoot, "node_modules"), { recursive: true });
+      cleanups.push(projectRoot);
+
+      // Simulate a worktree inside .gsd/worktrees/<name>/
+      const worktreeDir = join(projectRoot, ".gsd", "worktrees", "slice-abc");
+      mkdirSync(worktreeDir, { recursive: true });
+      writeFileSync(
+        join(worktreeDir, "package.json"),
+        JSON.stringify({ name: "test-project" }),
+      );
+      // node_modules intentionally absent — this is the bug scenario
+
+      const results = runEnvironmentChecks(worktreeDir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+
+      // Before fix: this would return status "error" with "node_modules missing"
+      // After fix: should return "ok" because project root has node_modules
+      assertTrue(
+        depsCheck === undefined || depsCheck.status !== "error",
+        "worktree should not report env_dependencies error when project root has node_modules",
+      );
+    }
+
+    // ── Worktree with NO node_modules anywhere should still error ──────
+    console.log("\n=== worktree: missing node_modules everywhere should still error ===");
+    {
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      cleanups.push(projectRoot);
+      // No node_modules at project root either
+
+      const worktreeDir = join(projectRoot, ".gsd", "worktrees", "slice-xyz");
+      mkdirSync(worktreeDir, { recursive: true });
+      writeFileSync(
+        join(worktreeDir, "package.json"),
+        JSON.stringify({ name: "test-project" }),
+      );
+
+      const results = runEnvironmentChecks(worktreeDir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assertTrue(depsCheck !== undefined, "dependencies check still runs in worktree");
+      assertEq(depsCheck!.status, "error", "reports error when node_modules missing everywhere");
+    }
+
+    // ── Worktree env_dependencies not in doctor issues ──────────────────
+    console.log("\n=== worktree: checkEnvironmentHealth should not add env_dependencies for valid worktree ===");
+    {
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      mkdirSync(join(projectRoot, "node_modules"), { recursive: true });
+      cleanups.push(projectRoot);
+
+      const worktreeDir = join(projectRoot, ".gsd", "worktrees", "slice-pr");
+      mkdirSync(worktreeDir, { recursive: true });
+      writeFileSync(
+        join(worktreeDir, "package.json"),
+        JSON.stringify({ name: "test-project" }),
+      );
+
+      const issues: any[] = [];
+      await checkEnvironmentHealth(worktreeDir, issues);
+      const depIssue = issues.find(i => i.code === "env_dependencies");
+      assertEq(
+        depIssue,
+        undefined,
+        "no env_dependencies issue for worktree with project root node_modules",
+      );
+    }
+
+    // ── Non-worktree path still catches missing node_modules ───────────
+    console.log("\n=== non-worktree: missing node_modules still detected ===");
+    {
+      const dir = createDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assertTrue(depsCheck !== undefined, "dependencies check runs");
+      assertEq(depsCheck!.status, "error", "missing node_modules is an error for non-worktree");
+    }
+
+    // ── GSD_WORKTREE env var detection ─────────────────────────────────
+    console.log("\n=== GSD_WORKTREE env: should resolve project root node_modules ===");
+    {
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      mkdirSync(join(projectRoot, "node_modules"), { recursive: true });
+      cleanups.push(projectRoot);
+
+      // Create a directory that doesn't have .gsd/worktrees in path but
+      // has GSD_WORKTREE env pointing to project root
+      const someDir = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      cleanups.push(someDir);
+
+      const origEnv = process.env.GSD_WORKTREE;
+      try {
+        process.env.GSD_WORKTREE = projectRoot;
+        const results = runEnvironmentChecks(someDir);
+        const depsCheck = results.find(r => r.name === "dependencies");
+        assertTrue(
+          depsCheck === undefined || depsCheck.status !== "error",
+          "GSD_WORKTREE env allows fallback to project root node_modules",
+        );
+      } finally {
+        if (origEnv === undefined) {
+          delete process.env.GSD_WORKTREE;
+        } else {
+          process.env.GSD_WORKTREE = origEnv;
+        }
+      }
+    }
+
+  } finally {
+    for (const dir of cleanups) {
+      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  report();
+}
+
+main();