gsd-pi 2.65.0 → 2.66.0-dev.e159299

package/src/resources/extensions/gsd/tests/import-done-milestones.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Regression test for #3699 — import milestones with all-done slices as complete
+ *
+ * During DB migration, milestones whose roadmap slices are all marked done
+ * should be imported with status "complete" instead of "active".
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const importerSrc = readFileSync(
+  join(__dirname, '..', 'md-importer.ts'),
+  'utf-8',
+);
+
+describe('import done milestones as complete (#3699)', () => {
+  test('all-slices-done check sets milestoneStatus to complete', () => {
+    // The importer should check if all roadmap slices are done
+    assert.match(importerSrc, /roadmap\.slices\.every\(s\s*=>\s*s\.done\)/,
+      'should check roadmap.slices.every(s => s.done)');
+  });
+
+  test('milestoneStatus is set to complete when all slices done', () => {
+    // Find the all-done guard and verify it sets 'complete'
+    const everyIdx = importerSrc.indexOf('roadmap.slices.every(s => s.done)');
+    assert.ok(everyIdx > -1, 'all-slices-done check should exist');
+    const afterCheck = importerSrc.slice(everyIdx, everyIdx + 200);
+    assert.match(afterCheck, /milestoneStatus\s*=\s*'complete'/,
+      'should set milestoneStatus to complete when all slices are done');
+  });
+
+  test('roadmap.slices.length > 0 guard prevents false positives', () => {
+    assert.match(importerSrc, /roadmap\.slices\.length\s*>\s*0/,
+      'should guard against empty slices array');
+  });
+});

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -454,7 +454,7 @@ test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (
   );
 });
 
-test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#1691)", (t) => {
+test("verifyExpectedArtifact execute-task rejects heading-style plan without checked checkbox (#3607)", (t) => {
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
@@ -471,10 +471,12 @@ test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#
     "Feature description.",
   ].join("\n"));
   writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone.");
+  // Heading-style entries no longer count as verified — only checked
+  // checkboxes prove gsd_complete_task ran (#3607).
   assert.strictEqual(
     verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
-    true,
-    "execute-task should pass for heading-style plan entry when summary exists",
+    false,
+    "heading-style without checked checkbox should NOT pass verification",
   );
 });
 
@@ -682,7 +684,7 @@ function makeGitBase(): string {
   return base;
 }
 
-test("hasImplementationArtifacts returns false when only .gsd/ files committed (#1703)", (t) => {
+test("hasImplementationArtifacts returns 'absent' when only .gsd/ files committed (#1703)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));
 
@@ -695,10 +697,10 @@ test("hasImplementationArtifacts returns false when only .gsd/ files committed (
   execFileSync("git", ["commit", "-m", "chore: add plan files"], { cwd: base, stdio: "ignore" });
 
   const result = hasImplementationArtifacts(base);
-  assert.equal(result, false, "should return false when only .gsd/ files were committed");
+  assert.equal(result, "absent", "should return 'absent' when only .gsd/ files were committed");
 });
 
-test("hasImplementationArtifacts returns true when implementation files committed (#1703)", (t) => {
+test("hasImplementationArtifacts returns 'present' when implementation files committed (#1703)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));
 
@@ -712,16 +714,16 @@ test("hasImplementationArtifacts returns true when implementation files committe
   execFileSync("git", ["commit", "-m", "feat: add feature"], { cwd: base, stdio: "ignore" });
 
   const result = hasImplementationArtifacts(base);
-  assert.equal(result, true, "should return true when implementation files are present");
+  assert.equal(result, "present", "should return 'present' when implementation files are present");
 });
 
-test("hasImplementationArtifacts returns true on non-git directory (fail-open)", (t) => {
+test("hasImplementationArtifacts returns 'unknown' on non-git directory (fail-open)", (t) => {
   const base = join(tmpdir(), `gsd-test-nogit-${randomUUID()}`);
   mkdirSync(base, { recursive: true });
   t.after(() => cleanup(base));
 
   const result = hasImplementationArtifacts(base);
-  assert.equal(result, true, "should return true (fail-open) in non-git directory");
+  assert.equal(result, "unknown", "should return 'unknown' (fail-open) in non-git directory");
 });
 
 // ─── verifyExpectedArtifact: complete-milestone requires impl artifacts (#1703) ──

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -920,8 +920,10 @@ describe("completion and verification failures", () => {
     base = createFullFixture();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Active", status: "active" });
-    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "complete" });
-    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "complete" });
+    // Use "pending" status — closed slices (complete/done/skipped) are
+    // excluded from SUMMARY checks per #3620.
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "pending" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
     // No S01-SUMMARY.md or S02-SUMMARY.md on disk
 
     const ctx = buildDispatchCtx(base, "M001", {

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -11,6 +11,8 @@
 
 // GSD State Machine Live Validation (#3161)
 
+
+
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -721,10 +723,10 @@ describe("state-machine-live-validation", () => {
       const result = await handleCompleteTask(makeTaskParams("T01", "S99", "M099") as any, base);
       assert.ok(!("error" in result), `expected success: ${JSON.stringify(result)}`);
 
-      // Phantom milestone created
+      // Phantom milestone created — H6 fix: now uses ID as title instead of empty string
       const milestone = getMilestone("M099");
       assert.ok(milestone, "phantom milestone M099 should exist");
-      assert.equal(milestone!.title, "", "phantom milestone has empty title");
+      assert.equal(milestone!.title, "M099", "H6 fix: phantom milestone uses ID as title");
 
       // Phantom slice created
       const slice = getSlice("M099", "S99");
@@ -895,13 +897,10 @@ describe("state-machine-live-validation", () => {
   // ─────────────────────────────────────────────────────────────────────────
 
   describe("reopen-then-redo cycle", () => {
-    test("complete → reopen → M12: stale SUMMARY causes immediate auto-reconcile", async () => {
-      // Finding M12: reopen-task does NOT delete the SUMMARY.md from disk.
-      // The reopen handler's own post-mutation hook calls renderAllProjections
-      // which triggers deriveStateFromDb, which sees the stale SUMMARY.md and
-      // auto-reconciles the task BACK to "complete" (#2514) within the same call.
-      //
-      // Result: the reopen is effectively a no-op when filesystem artifacts exist.
+    test("complete → reopen → re-complete task works end-to-end (M12 fixed)", async () => {
+      // M12 fix: reopen-task now deletes SUMMARY.md from disk before the
+      // post-mutation hook runs, preventing the reconciler from auto-correcting
+      // the task back to "complete".
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -915,23 +914,23 @@ describe("state-machine-live-validation", () => {
       const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
       assert.ok(existsSync(summaryPath), "SUMMARY.md exists after completion");
 
-      // Reopen — handler sets DB to "pending" in transaction, but post-mutation
-      // hook triggers reconciler which immediately sets it back to "complete"
+      // Reopen — now deletes SUMMARY.md from disk (M12 fix)
       const r2 = await handleReopenTask({ milestoneId: "M001", sliceId: "S01", taskId: "T01" }, base);
-      assert.ok(!("error" in r2), `reopen handler succeeded: ${JSON.stringify(r2)}`);
+      assert.ok(!("error" in r2), `reopen: ${JSON.stringify(r2)}`);
 
-      // M12: After reopen completes, DB shows "complete" not "pending" because
-      // the reconciler auto-corrected it from the stale SUMMARY.md
-      const task = getTask("M001", "S01", "T01");
-      assert.equal(task!.status, "complete", "M12: reconciler overrides reopen — task is back to complete");
-      assert.ok(existsSync(summaryPath), "M12: SUMMARY.md was never cleaned up");
+      // Task is now properly pending — SUMMARY.md was cleaned up
+      assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
+      assert.ok(!existsSync(summaryPath), "M12 fix: SUMMARY.md cleaned up by reopen");
+
+      // Re-complete succeeds
+      const r3 = await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      assert.ok(!("error" in r3), `re-complete: ${JSON.stringify(r3)}`);
+      assert.ok(isClosedStatus(getTask("M001", "S01", "T01")!.status));
     });
 
-    test("complete slice → reopen → M12: reconciler overrides task reset via stale SUMMARY", async () => {
-      // Same M12 pattern at the slice level: reopen-slice resets all tasks to
-      // "pending" in DB, but task SUMMARY.md artifacts remain on disk. The
-      // reopen handler's post-mutation hook triggers reconciler which sees the
-      // stale artifacts and auto-corrects tasks back to "complete".
+    test("complete slice → reopen → re-complete all works end-to-end (M12 fixed)", async () => {
+      // M12 fix: reopen-slice now deletes all SUMMARY.md and UAT.md artifacts
+      // from disk, preventing reconciler interference.
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -943,17 +942,16 @@ describe("state-machine-live-validation", () => {
       await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
 
-      // Reopen slice — transaction resets slice to in_progress and task to pending,
-      // but post-mutation hook triggers reconciler which sees stale SUMMARY.md
+      // Reopen slice — now cleans up all artifacts (M12 fix)
       await handleReopenSlice({ milestoneId: "M001", sliceId: "S01" }, base);
-
-      // Slice status is correctly in_progress (no slice SUMMARY reconciliation)
       assert.equal(getSlice("M001", "S01")!.status, "in_progress");
+      assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
 
-      // M12: Task was reset to "pending" in the transaction, but reconciler
-      // already corrected it back to "complete" from the stale SUMMARY.md
-      const task = getTask("M001", "S01", "T01");
-      assert.equal(task!.status, "complete", "M12: reconciler overrides reopen — task back to complete");
+      // Re-complete task + slice succeeds
+      await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      const r = await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
+      assert.ok(!("error" in r), `re-complete slice: ${JSON.stringify(r)}`);
+      assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
     });
   });
 });

package/src/resources/extensions/gsd/tests/integration/test-isolation.ts

@@ -0,0 +1,53 @@
+/**
+ * Test isolation utilities for integration tests.
+ *
+ * Integration tests often call `mergeMilestoneToMain` and other functions that
+ * load preferences. If the user's global ~/.gsd/preferences.md has
+ * `git.main_branch: master`, tests fail because test repos use `main`.
+ *
+ * These utilities isolate tests from the user's global environment.
+ */
+
+import { mkdtempSync, rmSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _resetServiceCache } from "../../worktree.ts";
+import { _clearGsdRootCache } from "../../paths.ts";
+
+let originalHome: string | undefined;
+let fakeHome: string | null = null;
+
+/**
+ * Isolate the test environment from user's global preferences.
+ * Creates a fake HOME directory so loadEffectiveGSDPreferences() returns
+ * empty global preferences instead of the user's ~/.gsd/preferences.md.
+ *
+ * Call this in a test.before() hook.
+ */
+export function isolateFromGlobalPreferences(): void {
+  originalHome = process.env.HOME;
+  fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-test-home-")));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+}
+
+/**
+ * Restore the original HOME and clean up the fake home directory.
+ *
+ * Call this in a test.after() hook.
+ */
+export function restoreGlobalPreferences(): void {
+  if (originalHome !== undefined) {
+    process.env.HOME = originalHome;
+  } else {
+    delete process.env.HOME;
+  }
+  _clearGsdRootCache();
+  _resetServiceCache();
+  if (fakeHome) {
+    rmSync(fakeHome, { recursive: true, force: true });
+    fakeHome = null;
+  }
+}