gsd-pi 2.64.0-dev.f8aad9b → 2.65.0-dev.16e10d7

package/src/resources/extensions/gsd/tests/error-success-mask.test.ts

@@ -0,0 +1,37 @@
+/**
+ * error-success-mask.test.ts — #3664
+ *
+ * Verify that the agent-end-recovery error handler detects when errorMessage
+ * is uninformative (e.g. "success", "ok", "unknown") and falls back to
+ * extracting the real error from the assistant message text content.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceFile = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+
+describe("error-success mask detection (#3664)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("detects useless errorMessage values with regex", () => {
+    assert.match(source, /success\|ok\|true\|error\|unknown/i);
+  });
+
+  test("extracts display message from content text block", () => {
+    assert.match(source, /textBlock/);
+    assert.match(source, /\.text\.slice\(0,\s*300\)/);
+  });
+
+  test("classifies using rawErrorMsg, not displayMsg", () => {
+    assert.match(source, /classifyError\(rawErrorMsg/);
+  });
+
+  test("references issue #3588 in comments", () => {
+    assert.match(source, /#3588/);
+  });
+});

package/src/resources/extensions/gsd/tests/find-missing-summaries-closed.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Regression test for #3669 — findMissingSummaries skips closed slices
+ *
+ * When a slice has status "skipped", "complete", or "done", it should be
+ * excluded from the missing-summary check because closed slices intentionally
+ * lack SUMMARY files (or their DB status is authoritative).
+ *
+ * This is a structural verification test — it reads the source to confirm the
+ * CLOSED_STATUSES guard exists at the filter site.
+ */
+
+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 source = readFileSync(join(__dirname, '..', 'auto-dispatch.ts'), 'utf-8');
+
+describe('findMissingSummaries closed-status exclusion (#3669)', () => {
+  test('CLOSED_STATUSES set includes skipped, complete, and done', () => {
+    // The source must define a CLOSED_STATUSES set with all three statuses
+    assert.match(source, /CLOSED_STATUSES.*=.*new Set\(/,
+      'CLOSED_STATUSES set should be defined');
+    assert.match(source, /"skipped"/, 'CLOSED_STATUSES should include "skipped"');
+    assert.match(source, /"complete"/, 'CLOSED_STATUSES should include "complete"');
+    assert.match(source, /"done"/, 'CLOSED_STATUSES should include "done"');
+  });
+
+  test('filter uses CLOSED_STATUSES.has() to exclude closed slices', () => {
+    assert.match(source, /CLOSED_STATUSES\.has\(s\.status\)/,
+      'filter should call CLOSED_STATUSES.has(s.status)');
+  });
+
+  test('findMissingSummaries function exists', () => {
+    assert.match(source, /function findMissingSummaries\(/,
+      'findMissingSummaries function should be defined');
+  });
+
+  test('filter is negated (excludes closed, keeps open)', () => {
+    // The filter should use !CLOSED_STATUSES.has() to exclude closed slices
+    assert.match(source, /!CLOSED_STATUSES\.has\(s\.status\)/,
+      'filter should negate CLOSED_STATUSES.has() to exclude closed slices');
+  });
+});

package/src/resources/extensions/gsd/tests/frontmatter-parse-noise.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Regression test for #3693 — suppress repeated frontmatter parse warnings
+ *
+ * parseFrontmatterBlock was logging a YAML parse warning on every call.
+ * The fix adds a _warnedFrontmatterParse flag so the warning only fires once.
+ */
+
+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 prefsSrc = readFileSync(
+  join(__dirname, '..', 'preferences.ts'),
+  'utf-8',
+);
+
+describe('frontmatter parse noise suppression (#3693)', () => {
+  test('_warnedFrontmatterParse flag is defined', () => {
+    assert.match(prefsSrc, /_warnedFrontmatterParse/,
+      '_warnedFrontmatterParse flag should exist in preferences.ts');
+  });
+
+  test('parseFrontmatterBlock function exists', () => {
+    assert.match(prefsSrc, /function parseFrontmatterBlock\(/,
+      'parseFrontmatterBlock function should be defined');
+  });
+
+  test('flag is checked before warning', () => {
+    assert.match(prefsSrc, /if\s*\(\s*!_warnedFrontmatterParse\s*\)/,
+      'should check !_warnedFrontmatterParse before logging');
+  });
+
+  test('flag is set to true after first warning', () => {
+    assert.match(prefsSrc, /_warnedFrontmatterParse\s*=\s*true/,
+      'should set _warnedFrontmatterParse = true after warning');
+  });
+});

package/src/resources/extensions/gsd/tests/gitignore-bg-shell.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Regression test — .bg-shell/ added to BASELINE_PATTERNS in gitignore.ts
+ *
+ * The bg-shell background process directory was not included in the
+ * baseline gitignore patterns, causing it to appear as untracked in
+ * git status and potentially be committed.
+ *
+ * Structural verification test — reads source to confirm .bg-shell/
+ * is in BASELINE_PATTERNS.
+ */
+
+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 source = readFileSync(join(__dirname, '..', 'gitignore.ts'), 'utf-8');
+
+describe('.bg-shell/ in BASELINE_PATTERNS', () => {
+  test('BASELINE_PATTERNS array is defined', () => {
+    assert.match(source, /const BASELINE_PATTERNS\s*=/,
+      'BASELINE_PATTERNS should be defined');
+  });
+
+  test('.bg-shell/ is included in BASELINE_PATTERNS', () => {
+    // Extract the BASELINE_PATTERNS array content
+    const patternsStart = source.indexOf('BASELINE_PATTERNS');
+    const arrayStart = source.indexOf('[', patternsStart);
+    const arrayEnd = source.indexOf('] as const', arrayStart);
+    const patternsContent = source.slice(arrayStart, arrayEnd);
+    assert.match(patternsContent, /\.bg-shell\//,
+      '.bg-shell/ should be in BASELINE_PATTERNS');
+  });
+});

package/src/resources/extensions/gsd/tests/guided-flow-state-rebuild.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Regression test for #3475: guided-flow must rebuild STATE.md from derived
+ * state before dispatching workflows.
+ *
+ * Verifies that buildStateMarkdown() produces content matching the derived
+ * state (not a stale on-disk cache), and that the rebuild helper is wired
+ * correctly from doctor.ts.
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveState, invalidateStateCache } from "../state.ts";
+import { buildStateMarkdown, rebuildState } from "../doctor.ts";
+import { resolveGsdRootFile } from "../paths.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-state-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, ".gsd", relativePath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+describe("guided-flow STATE.md rebuild (#3475)", () => {
+  let base: string;
+
+  afterEach(() => {
+    closeDatabase();
+    if (base) rmSync(base, { recursive: true, force: true });
+  });
+
+  test("rebuildState writes STATE.md matching derived state, not stale cache", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // Set up real active milestone M010
+    insertMilestone({ id: "M010", title: "Real Active", status: "active" });
+    insertSlice({ id: "S03", milestoneId: "M010", title: "Slice Three", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T05", sliceId: "S03", milestoneId: "M010", title: "Task Five", status: "pending" });
+    writeFile(base, "milestones/M010/M010-CONTEXT.md", "# M010: Real Active\n\nReal work here.");
+    writeFile(base, "milestones/M010/M010-ROADMAP.md", "# M010\n\n## Slices\n\n- [ ] **S03: Slice Three**");
+
+    // Write a STALE STATE.md pointing to wrong milestone
+    writeFile(base, "STATE.md", [
+      "# GSD State",
+      "",
+      "**Active Milestone:** M008: Old Queued",
+      "**Active Slice:** None",
+      "**Phase:** pre-planning",
+      "",
+      "## Next Action",
+      "Milestone M008 has a roadmap but no slices defined.",
+    ].join("\n"));
+
+    // Derive state — should return M010
+    invalidateStateCache();
+    const state = await deriveState(base);
+    assert.equal(state.activeMilestone?.id, "M010", "Derived state should be M010");
+
+    // Rebuild STATE.md
+    await rebuildState(base);
+
+    // Read the rebuilt STATE.md
+    const statePath = resolveGsdRootFile(base, "STATE");
+    const rebuilt = readFileSync(statePath, "utf-8");
+
+    // Should contain M010, NOT M008
+    assert.ok(rebuilt.includes("M010"), "Rebuilt STATE.md should reference M010");
+    assert.ok(!rebuilt.includes("M008"), "Rebuilt STATE.md should NOT reference stale M008");
+  });
+
+  test("buildStateMarkdown produces correct active milestone from GSDState", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    insertMilestone({ id: "M070", title: "Current Work", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M070", title: "First Slice", status: "active", risk: "low", depends: [] });
+    writeFile(base, "milestones/M070/M070-CONTEXT.md", "# M070: Current Work");
+    writeFile(base, "milestones/M070/M070-ROADMAP.md", "# M070\n\n## Slices\n\n- [ ] **S01: First Slice**");
+
+    invalidateStateCache();
+    const state = await deriveState(base);
+    const md = buildStateMarkdown(state);
+
+    assert.ok(md.includes("M070"), "State markdown should include active milestone M070");
+    assert.ok(md.includes("Current Work") || md.includes("M070"), "State markdown should include milestone title or ID");
+  });
+});

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

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