gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

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