gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -13,7 +13,7 @@ import { buildCompleteMilestonePrompt, buildValidateMilestonePrompt } from "../a
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
-import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase, getMilestone } from "../gsd-db.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -41,6 +41,12 @@ function writeRoadmap(base: string, mid: string, content: string): void {
   writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
 }
 
+function writeContext(base: string, mid: string, content = "# M001 Context\n\nValidated context."): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), content);
+}
+
 function writeMilestoneSummary(base: string, mid: string, content: string): void {
   const dir = join(base, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -177,16 +183,22 @@ test("deriveState returns completing-milestone when VALIDATION exists with termi
   }
 });
 
-test("deriveState treats needs-remediation as non-terminal — re-enters validating-milestone (#832)", async () => {
+test("deriveState returns blocked when needs-remediation has no incomplete slices (#4506)", async () => {
   const base = makeTmpBase();
   try {
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeValidation(base, "M001", "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds fixes.");
 
     const state = await deriveState(base);
-    // needs-remediation routes back to validating-milestone for re-validation
-    assert.equal(state.phase, "validating-milestone");
+    // All slices done + needs-remediation → blocked (prevents infinite
+    // validate-milestone dispatch loop). Previously returned
+    // validating-milestone, which caused #4506.
+    assert.equal(state.phase, "blocked");
     assert.equal(state.activeMilestone?.id, "M001");
+    assert.ok(
+      state.blockers.some(b => b.includes("needs-remediation") && b.includes("M001")),
+      "blocker message should mention milestone and verdict",
+    );
   } finally {
     cleanup(base);
   }
@@ -251,14 +263,15 @@ Test
 `);
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
-    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
-    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [] });
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
 
     const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
     assert.match(prompt, /S01 Summary/i, "prompt should inline non-skipped slice summaries");
     assert.doesNotMatch(prompt, /### S02 Summary/i, "prompt should not inline skipped slice summaries");
     assert.doesNotMatch(prompt, /not found — file does not exist yet/i, "prompt should not emit skipped-slice missing-file placeholders");
+    assert.doesNotMatch(prompt, /S02-SUMMARY\.md/, "skipped slice must not appear in on-demand path list (#4780)");
   } finally {
     cleanup(base);
   }
@@ -290,8 +303,8 @@ Test
 `);
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
-    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
-    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [] });
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
     writeSliceAssessment(base, "M001", "S01", "---\nverdict: PASS\n---\n# Assessment\nEvidence captured.");
 
@@ -322,6 +335,7 @@ test("dispatch rule matches validating-milestone phase", async () => {
   const base = makeTmpBase();
   try {
     // Set up minimal milestone structure for the prompt builder
+    writeContext(base, "M001");
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
@@ -358,6 +372,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
 
   const base = makeTmpBase();
   try {
+    writeContext(base, "M001");
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
@@ -379,6 +394,131 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   }
 });
 
+test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is not complete (#4658)", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "completing-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Complete milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
+    writeMilestoneSummary(base, "M001", "# Milestone Summary\nverification FAILED — not complete.");
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "stop");
+    if (result.action === "stop") {
+      assert.equal(result.level, "warning");
+      assert.match(result.reason, /failure-path SUMMARY/i);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "completing-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Complete milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
+    writeMilestoneSummary(
+      base,
+      "M001",
+      [
+        "---",
+        "id: M001",
+        "status: complete",
+        "---",
+        "",
+        "# M001: Test",
+        "",
+        "**Complete.**",
+      ].join("\n"),
+    );
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "skip");
+    const milestone = getMilestone("M001");
+    assert.equal(milestone?.status, "complete");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "completing-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Complete milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
+    writeMilestoneSummary(base, "M001", "# M001 Summary\nSome notes without completion metadata.");
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "stop");
+    if (result.action === "stop") {
+      assert.equal(result.level, "warning");
+      assert.match(result.reason, /ambiguous SUMMARY/i);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Artifact resolution & verification ───────────────────────────────────
 
 test("resolveExpectedArtifactPath returns VALIDATION path for validate-milestone", () => {

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -1,89 +1,153 @@
 /**
- * Regression test for #3607 — tighten verifyExpectedArtifact legacy branch
+ * Regression test for #3607 — tighten verifyExpectedArtifact legacy branch.
  *
  * The legacy (pre-migration) fallback in verifyExpectedArtifact previously
  * accepted either a heading match (### T01 --) or a checked checkbox as proof
  * that gsd_complete_task ran. A heading alone does not prove completion —
  * it could result from a rogue write.
  *
- * The fix removes the hdRe heading regex and requires only a checked checkbox
- * (cbRe) in the legacy branch, ensuring that only actual tool-completed tasks
- * are treated as verified.
+ * These tests exercise verifyExpectedArtifact directly for execute-task units
+ * when the DB is unavailable (legacy branch). Only a checked checkbox in the
+ * slice plan counts as evidence of completion; a bare heading or an unchecked
+ * checkbox must not pass.
  */
 
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'auto-recovery.ts'),
-  'utf-8',
-)
-
-describe('verifyExpectedArtifact legacy branch tightened (#3607)', () => {
-  it('legacy branch does NOT define hdRe heading regex', () => {
-    // Find the legacy fallback section
-    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
-    assert.ok(legacyIdx !== -1, 'LEGACY comment must exist')
-
-    // Check the code within a reasonable window after the LEGACY comment
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
-
-    assert.ok(
-      !legacyBlock.includes('hdRe'),
-      'hdRe heading regex must NOT exist in legacy branch — heading alone is not proof of completion',
-    )
-  })
-
-  it('legacy branch requires checked checkbox via cbRe', () => {
-    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
-    assert.ok(legacyIdx !== -1)
-
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 600)
-
-    assert.ok(
-      legacyBlock.includes('cbRe'),
-      'cbRe checked-checkbox regex must exist in legacy branch',
-    )
-
-    // cbRe must match checked checkboxes [x] or [X]
-    assert.ok(
-      legacyBlock.includes('[xX]'),
-      'cbRe must match both [x] and [X] checkbox variants',
-    )
-  })
-
-  it('legacy branch returns false when no plan file exists', () => {
-    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
-    assert.ok(legacyIdx !== -1)
-
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
-
-    // The else branch: no plan file means cannot verify
-    assert.ok(
-      legacyBlock.includes('no plan file'),
-      'missing plan file must be handled with return false',
-    )
-  })
-
-  it('DB available but task not found returns false', () => {
-    const legacyIdx = src.indexOf('LEGACY: Pre-migration fallback')
-    assert.ok(legacyIdx !== -1)
-
-    const legacyBlock = src.slice(legacyIdx, legacyIdx + 1000)
-
-    assert.ok(
-      legacyBlock.includes('DB available but task row not found'),
-      'must handle case where DB is available but task row is missing',
-    )
-
-    // The comment should be followed by a return false
-    const commentIdx = legacyBlock.indexOf('DB available but task row not found')
-    const afterComment = legacyBlock.slice(commentIdx, commentIdx + 200)
-    assert.ok(
-      afterComment.includes('return false'),
-      'missing task row when DB available must return false',
-    )
-  })
-})
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { verifyExpectedArtifact } from "../auto-recovery.ts";
+import { closeDatabase, isDbAvailable } from "../gsd-db.ts";
+
+/** Scaffold .gsd/milestones/M001/slices/S01/ with tasks/ and a T01-SUMMARY.md. */
+function scaffoldProject(t: { after: (fn: () => void) => void }): {
+  base: string;
+  planPath: string;
+} {
+  const base = mkdtempSync(join(tmpdir(), "gsd-verify-artifact-"));
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(join(sliceDir, "tasks"), { recursive: true });
+  // Summary file must exist so verifyExpectedArtifact reaches the legacy branch
+  writeFileSync(join(sliceDir, "tasks", "T01-SUMMARY.md"), "# T01 summary\n");
+  return { base, planPath: join(sliceDir, "S01-PLAN.md") };
+}
+
+test("#3607: execute-task legacy branch — checked checkbox [x] passes verification", (t) => {
+  closeDatabase();
+  assert.equal(isDbAvailable(), false, "DB must be closed to hit legacy branch");
+
+  const { base, planPath } = scaffoldProject(t);
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "- [x] **T01: Implement feature**",
+      "",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    true,
+    "checked checkbox [x] is accepted as completion evidence",
+  );
+});
+
+test("#3607: execute-task legacy branch — checked checkbox [X] (uppercase) also passes", (t) => {
+  closeDatabase();
+  const { base, planPath } = scaffoldProject(t);
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "- [X] **T01: Implement feature**",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    true,
+    "uppercase [X] checkbox is accepted",
+  );
+});
+
+test("#3607: execute-task legacy branch — unchecked checkbox [ ] is rejected", (t) => {
+  closeDatabase();
+  const { base, planPath } = scaffoldProject(t);
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "- [ ] **T01: Implement feature**",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    false,
+    "unchecked checkbox [ ] must not pass verification (#3607)",
+  );
+});
+
+test("#3607: execute-task legacy branch — bare heading ### T01 is no longer sufficient", (t) => {
+  closeDatabase();
+  const { base, planPath } = scaffoldProject(t);
+  // Old buggy behaviour would pass on a heading alone. This must now fail.
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Some description here, but no checkbox.",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    false,
+    "heading alone must not pass verification after #3607 fix",
+  );
+});
+
+test("#3607: execute-task legacy branch — missing plan file returns false", (t) => {
+  closeDatabase();
+  const { base } = scaffoldProject(t);
+  // Do not create S01-PLAN.md at all.
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    false,
+    "missing plan file must cause verification to return false",
+  );
+});
+
+test("#3607: execute-task legacy branch — wrong task id in checkbox does not match", (t) => {
+  closeDatabase();
+  const { base, planPath } = scaffoldProject(t);
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "- [x] **T02: Some other task**",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    false,
+    "checkbox for a different task id must not count as T01 completion",
+  );
+});

package/src/resources/extensions/gsd/tests/visualizer-critical-path.test.ts

@@ -3,9 +3,8 @@
 
 import { computeCriticalPath } from "../visualizer-data.js";
 import type { VisualizerMilestone } from "../visualizer-data.js";
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-
+import { test } from "node:test";
+import assert from "node:assert/strict";
 
 function makeMs(id: string, status: "complete" | "active" | "pending", dependsOn: string[], slices: any[] = []): VisualizerMilestone {
   return { id, title: id, status, dependsOn, slices };
@@ -15,12 +14,7 @@ function makeSlice(id: string, done: boolean, depends: string[] = []) {
   return { id, title: id, done, active: false, risk: "low", depends, tasks: [] };
 }
 
-// ─── Linear chain ───────────────────────────────────────────────────────────
-
-console.log("\n=== Critical Path: Linear Chain ===");
-
-{
-  // M001 -> M002 -> M003
+test("critical path: linear chain M001 → M002 → M003", () => {
   const milestones = [
     makeMs("M001", "complete", []),
     makeMs("M002", "active", ["M001"], [
@@ -34,15 +28,11 @@ console.log("\n=== Critical Path: Linear Chain ===");
   assert.ok(cp.milestonePath.length > 0, "linear chain has critical path");
   assert.ok(cp.milestonePath.includes("M002"), "M002 is on critical path");
   assert.ok(cp.milestonePath.includes("M003"), "M003 is on critical path");
-  assert.deepStrictEqual(cp.milestoneSlack.get("M002"), 0, "M002 has zero slack");
-  assert.deepStrictEqual(cp.milestoneSlack.get("M003"), 0, "M003 has zero slack");
-}
-
-// ─── Diamond DAG ────────────────────────────────────────────────────────────
+  assert.equal(cp.milestoneSlack.get("M002"), 0, "M002 has zero slack");
+  assert.equal(cp.milestoneSlack.get("M003"), 0, "M003 has zero slack");
+});
 
-console.log("\n=== Critical Path: Diamond DAG ===");
-
-{
+test("critical path: diamond DAG picks heavier branch", () => {
   // M001 -> M002 -> M004
   // M001 -> M003 -> M004
   // M002 has 3 incomplete slices, M003 has 1 incomplete slice
@@ -61,21 +51,13 @@ console.log("\n=== Critical Path: Diamond DAG ===");
 
   const cp = computeCriticalPath(milestones);
   assert.ok(cp.milestonePath.length >= 2, "diamond DAG has critical path");
-  // M002 has weight 3 (3 incomplete), M003 has weight 1
-  // Critical path should go through M002 (longer)
   assert.ok(cp.milestonePath.includes("M002"), "M002 (heavier) is on critical path");
 
-  // M003 should have non-zero slack since it's lighter
   const m003Slack = cp.milestoneSlack.get("M003") ?? -1;
   assert.ok(m003Slack > 0, "M003 has positive slack (lighter branch)");
-}
-
-// ─── Independent branches ───────────────────────────────────────────────────
+});
 
-console.log("\n=== Critical Path: Independent Branches ===");
-
-{
-  // M001 (no deps), M002 (no deps), M003 (no deps)
+test("critical path: independent branches selects longest", () => {
   const milestones = [
     makeMs("M001", "active", [], [makeSlice("S01", false)]),
     makeMs("M002", "pending", [], [makeSlice("S01", false), makeSlice("S02", false)]),
@@ -84,15 +66,10 @@ console.log("\n=== Critical Path: Independent Branches ===");
 
   const cp = computeCriticalPath(milestones);
   assert.ok(cp.milestonePath.length >= 1, "independent branches have at least one critical node");
-  // M002 has the most incomplete slices, should be critical
   assert.ok(cp.milestonePath.includes("M002"), "M002 (longest) is on critical path");
-}
+});
 
-// ─── Slice-level critical path ──────────────────────────────────────────────
-
-console.log("\n=== Critical Path: Slice-level ===");
-
-{
+test("critical path: slice-level path within an active milestone", () => {
   // Active milestone with slice dependencies: S01 -> S02 -> S04, S01 -> S03
   const milestones = [
     makeMs("M001", "active", [], [
@@ -108,26 +85,17 @@ console.log("\n=== Critical Path: Slice-level ===");
   assert.ok(cp.slicePath.includes("S02"), "S02 is on slice critical path");
   assert.ok(cp.slicePath.includes("S04"), "S04 is on slice critical path");
 
-  // S03 should have non-zero slack (it's a shorter branch)
   const s03Slack = cp.sliceSlack.get("S03") ?? -1;
   assert.ok(s03Slack > 0, "S03 has positive slack (shorter branch)");
-}
-
-// ─── Empty milestones ───────────────────────────────────────────────────────
-
-console.log("\n=== Critical Path: Empty ===");
+});
 
-{
+test("critical path: empty milestones produce empty paths", () => {
   const cp = computeCriticalPath([]);
-  assert.deepStrictEqual(cp.milestonePath.length, 0, "empty milestones produce empty path");
-  assert.deepStrictEqual(cp.slicePath.length, 0, "empty milestones produce empty slice path");
-}
-
-// ─── Single milestone ───────────────────────────────────────────────────────
-
-console.log("\n=== Critical Path: Single Milestone ===");
+  assert.equal(cp.milestonePath.length, 0, "empty milestones produce empty path");
+  assert.equal(cp.slicePath.length, 0, "empty milestones produce empty slice path");
+});
 
-{
+test("critical path: single milestone is its own critical path", () => {
   const milestones = [
     makeMs("M001", "active", [], [
       makeSlice("S01", false),
@@ -136,8 +104,6 @@ console.log("\n=== Critical Path: Single Milestone ===");
   ];
 
   const cp = computeCriticalPath(milestones);
-  assert.ok(cp.milestonePath.length === 1, "single milestone is its own critical path");
-  assert.deepStrictEqual(cp.milestonePath[0], "M001", "M001 is the critical node");
-}
-
-// ─── Report ─────────────────────────────────────────────────────────────────
+  assert.equal(cp.milestonePath.length, 1, "single milestone is its own critical path");
+  assert.equal(cp.milestonePath[0], "M001", "M001 is the critical node");
+});