gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/uok-gitops-wiring.test.ts

@@ -1,35 +1,58 @@
+/**
+ * UOK gitops wiring — post-unit pre-verification policy.
+ *
+ * Tests the pure policy bit that selects the turn-level git action from
+ * resolved UOK flags. The integration wiring (postUnitPreVerification
+ * calling runTurnGitAction, writeTurnGitTransaction, the UokGateRunner
+ * closeout pathway, and buildSnapshotOpts' trace/turn ID plumbing) is
+ * exercised end-to-end by the auto-loop and UOK kernel integration tests;
+ * the earlier source-grep assertions duplicated that coverage without
+ * actually exercising the code, and have been removed.
+ */
+
 import 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 gsdDir = join(__dirname, "..");
+import { resolveUokFlags } from "../uok/flags.ts";
+
+test("turn action defaults to commit when uok.gitops is enabled with no override", () => {
+  const flags = resolveUokFlags({ uok: { gitops: { enabled: true } } } as any);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.gitopsTurnAction, "commit");
+});
+
+test("turn action reflects uok.gitops.turn_action when set to snapshot", () => {
+  const flags = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_action: "snapshot" } },
+  } as any);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.gitopsTurnAction, "snapshot");
+});
 
-test("post-unit pre-verification selects turn git action from UOK gitops flags", () => {
-  const source = readFileSync(join(gsdDir, "auto-post-unit.ts"), "utf-8");
-  assert.ok(
-    source.includes("const turnAction: TurnGitActionMode = uokFlags.gitops ? uokFlags.gitopsTurnAction : \"commit\""),
-    "postUnitPreVerification should derive turn action from uok.gitops.turn_action when enabled",
-  );
+test("turn action reflects uok.gitops.turn_action when set to status-only", () => {
+  const flags = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_action: "status-only" } },
+  } as any);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.gitopsTurnAction, "status-only");
 });
 
-test("post-unit pre-verification routes git failures through closeout gate", () => {
-  const source = readFileSync(join(gsdDir, "auto-post-unit.ts"), "utf-8");
-  assert.ok(
-    source.includes('id: "closeout-git-action"') &&
-    source.includes('type: "closeout"') &&
-    source.includes('failureClass: "git"'),
-    "git failures should be persisted via a closeout gate with failureClass=git",
-  );
+test("turn_push flag round-trips through resolveUokFlags", () => {
+  const on = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_push: true } },
+  } as any);
+  const off = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_push: false } },
+  } as any);
+  assert.equal(on.gitopsTurnPush, true);
+  assert.equal(off.gitopsTurnPush, false);
 });
 
-test("auto snapshot opts carry trace/turn IDs for turn closeout records", () => {
-  const source = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
-  assert.ok(
-    source.includes("traceId: s.currentTraceId ?? undefined") &&
-    source.includes("turnId: s.currentTurnId ?? undefined"),
-    "buildSnapshotOpts should pass trace/turn IDs into closeout options",
-  );
+test("gitops disabled when uok.gitops.enabled is explicitly false", () => {
+  const flags = resolveUokFlags({
+    uok: { gitops: { enabled: false, turn_action: "snapshot" } },
+  } as any);
+  assert.equal(flags.gitops, false);
+  // Turn_action is still surfaced so callers can read their policy cleanly.
+  assert.equal(flags.gitopsTurnAction, "snapshot");
 });

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

@@ -271,6 +271,7 @@ Test
     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);
   }

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

@@ -1,90 +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'
-import { extractSourceRegion } from "./test-helpers.ts";
-
-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 = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
-
-    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 = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
-
-    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 = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
-
-    // 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 = extractSourceRegion(src, 'LEGACY: Pre-migration fallback')
-
-    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 = extractSourceRegion(legacyBlock, 'DB available but task row not found')
-    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");
+});