gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/pipeline-variant-dispatch.test.ts

@@ -0,0 +1,301 @@
+// GSD-2 — #4781 phase 2: dispatch-rule gates read pipeline variant from DB.
+// Behavior tests (not source-grep) — construct a real tmpdir DB, insert a
+// milestone whose planning fields classify to the target variant, exercise
+// DISPATCH_RULES.match(), assert the gate result.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import type { GSDState } from "../types.ts";
+
+const PARALLEL_RESEARCH_RULE = "planning (multiple slices need research) → parallel-research-slices";
+const SINGLE_RESEARCH_RULE = "planning (no research, not S01) → research-slice";
+const VALIDATE_RULE = "validating-milestone → validate-milestone";
+
+// ─── Fixture helpers ──────────────────────────────────────────────────────
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pipeline-variant-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+interface SeedOpts {
+  title: string;
+  vision: string;
+  successCriteria: string[];
+}
+
+function seedMilestone(base: string, mid: string, opts: SeedOpts): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: mid,
+    title: opts.title,
+    status: "active",
+    depends_on: [],
+  });
+  upsertMilestonePlanning(mid, {
+    title: opts.title,
+    status: "active",
+    vision: opts.vision,
+    successCriteria: opts.successCriteria,
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: mid,
+    title: "First",
+    status: "pending",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertSlice({
+    id: "S02",
+    milestoneId: mid,
+    title: "Second",
+    status: "pending",
+    risk: "low",
+    depends: ["S01"],
+    demo: "",
+    sequence: 2,
+  });
+}
+
+function findRule(name: string) {
+  const rule = DISPATCH_RULES.find(r => r.name === name);
+  assert.ok(rule, `rule "${name}" must exist`);
+  return rule!;
+}
+
+function makeCtx(params: {
+  base: string;
+  mid: string;
+  phase: GSDState["phase"];
+  activeSlice?: { id: string; title: string };
+}): DispatchContext {
+  const state: GSDState = {
+    phase: params.phase,
+    activeMilestone: { id: params.mid, title: "Test" },
+    activeSlice: params.activeSlice ?? null,
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: params.mid, title: "Test", status: "active" }],
+  };
+  return {
+    basePath: params.base,
+    mid: params.mid,
+    midTitle: "Test",
+    state,
+    prefs: undefined,
+  };
+}
+
+// Inputs that consistently classify.
+const TRIVIAL_INPUT: SeedOpts = {
+  title: "Static To-Do App",
+  vision: "A minimal, clean browser-based to-do app. Pure HTML/CSS/JS, no build step, no backend. Tasks persist in localStorage.",
+  successCriteria: [
+    "Open index.html in any browser without a server",
+    "Tasks survive a page reload via localStorage",
+  ],
+};
+
+const STANDARD_INPUT: SeedOpts = {
+  title: "Billing API extension",
+  vision: "Extend the billing API to charge usage-tier overages. Touch the invoice service, the entitlements cache, and the webhook handler.",
+  successCriteria: [
+    "Overage charges generate correct invoices",
+    "Integration tests cover tier rollovers",
+    "API endpoint returns structured error on webhook failure",
+  ],
+};
+
+// ─── Research-slice gate (single) ─────────────────────────────────────────
+
+test("#4781 phase 2: single research-slice rule skips dispatch for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  const ctx = makeCtx({
+    base,
+    mid: "M001",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  assert.strictEqual(result, null, "trivial variant must skip research-slice dispatch");
+});
+
+test("#4781 phase 2: single research-slice rule proceeds normally for standard variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", STANDARD_INPUT);
+  const ctx = makeCtx({
+    base,
+    mid: "M001",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  // No RESEARCH file exists → rule should reach the dispatch branch.
+  // We don't assert "dispatch" because the prompt builder may error with
+  // minimal fixture data; we assert "not null AND not a trivial-skip
+  // shortcut" by checking that if null was returned, it's for a known
+  // reason (research file exists). For this fixture none exists, so the
+  // result should be an action object.
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  assert.notStrictEqual(result, null, "standard variant must not short-circuit the research-slice gate");
+});
+
+// ─── Parallel research-slice gate ─────────────────────────────────────────
+
+test("#4781 phase 2: parallel-research-slices rule skips dispatch for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  // Roadmap needs to be readable for the parallel rule to enter its slice
+  // analysis. Write a minimal one.
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [ ] **S01: First** `risk:low` `depends:[]`",
+      "- [ ] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "planning" });
+  const result = await findRule(PARALLEL_RESEARCH_RULE).match(ctx);
+  assert.strictEqual(result, null, "trivial variant must skip parallel-research dispatch");
+});
+
+// ─── Validate-milestone gate ──────────────────────────────────────────────
+
+test("#4781 phase 2: validate-milestone rule writes pass-through VALIDATION for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  // findMissingSummaries checks slice SUMMARY files — write empty ones so
+  // the safety guard doesn't stop first.
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), "# S01\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-SUMMARY.md"), "# S02\n");
+  // Write a roadmap so findMissingSummaries can enumerate slice IDs.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+      "- [x] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "rule must return a result, not null");
+  assert.strictEqual(result!.action, "skip", "trivial variant must return skip action");
+
+  const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  assert.ok(existsSync(validationPath), "pass-through VALIDATION.md must be written");
+
+  const { readFileSync } = await import("node:fs");
+  const content = readFileSync(validationPath, "utf-8");
+  assert.match(content, /verdict: pass/);
+  assert.match(content, /trivial-scope pipeline variant \(#4781\)/);
+});
+
+test("#4781 phase 2: validate-milestone rule dispatches normally for standard variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", STANDARD_INPUT);
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), "# S01\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-SUMMARY.md"), "# S02\n");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+      "- [x] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "standard variant must produce a result");
+  assert.strictEqual(result!.action, "dispatch", "standard variant must dispatch validate-milestone");
+  if (result!.action === "dispatch") {
+    assert.strictEqual(result!.unitType, "validate-milestone");
+  }
+});
+
+// ─── Fallback safety: no DB, missing milestone ────────────────────────────
+
+test("#4781 phase 2: null variant (no milestone row) does NOT gate dispatch — safe fallback", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  // Open DB but do NOT seed any milestone — getMilestone returns null,
+  // which makes getMilestonePipelineVariant return null. Rules must NOT
+  // short-circuit on null (silent downshift is the hazard we're guarding
+  // against).
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const ctx = makeCtx({
+    base,
+    mid: "M999",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  // Rule should NOT return null from the variant gate. It may still return
+  // null for other reasons (e.g. missing active slice), but our assertion
+  // is specifically about the variant-gate not short-circuiting.
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  // Rule reaches its normal logic; with an active slice and no RESEARCH file,
+  // it should produce a dispatch action, not null from the variant gate.
+  assert.notStrictEqual(result, null, "null variant must not cause the research-slice gate to short-circuit");
+});

package/src/resources/extensions/gsd/tests/plan-gate-failed-doctor-heal-hint.test.ts

@@ -0,0 +1,37 @@
+/**
+ * Regression test for #4620.
+ *
+ * Ensures plan gate failed-closed errors include a self-heal hint
+ * directing users to /gsd doctor heal.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+function readSrc(file: string): string {
+  return readFileSync(join(gsdDir, file), "utf-8");
+}
+
+test("#4620: auto/phases plan gate failed message includes doctor heal hint", () => {
+  const src = readSrc("auto/phases.ts");
+  assert.match(
+    src,
+    /Plan gate failed-closed:[\s\S]*\/gsd doctor heal/,
+    "auto/phases.ts should include /gsd doctor heal in plan gate failed notification",
+  );
+});
+
+test("#4620: guided-flow plan gate failed message includes doctor heal hint", () => {
+  const src = readSrc("guided-flow.ts");
+  assert.match(
+    src,
+    /Plan gate failed-closed:[\s\S]*\/gsd doctor heal/,
+    "guided-flow.ts should include /gsd doctor heal in plan gate failed notification",
+  );
+});

package/src/resources/extensions/gsd/tests/pre-exec-gate-loop.test.ts

@@ -0,0 +1,272 @@
+/**
+ * pre-exec-gate-loop.test.ts — Regression tests for #4551.
+ *
+ * Verifies that when a pre-execution gate fails on a plan-slice unit:
+ *   1. `s.lastPreExecFailure` is populated on the AutoSession with the blocking
+ *      findings and a verdict excerpt.
+ *   2. The `planning → plan-slice` dispatch rule reads that field and injects a
+ *      "Fix these specific issues" section into the prompt.
+ *   3. The field is cleared (consumed) after the prompt is built so that stale
+ *      context does not bleed into an unrelated future plan-slice run.
+ *   4. When the failure belongs to a *different* unit ID, the dispatch rule
+ *      does NOT inject the stale context into the prompt.
+ */
+
+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 { AutoSession } from "../auto/session.ts";
+import { resolveDispatch } from "../auto-dispatch.ts";
+import type { DispatchContext } from "../auto-dispatch.ts";
+import { buildPlanSlicePrompt } from "../auto-prompts.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+import { deriveStateFromDb } from "../state.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeTempBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-4551-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function seedPlanningState(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Core Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "demo",
+    sequence: 1,
+    isSketch: false,
+  });
+  // Write minimal ROADMAP so state derivation doesn't error
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# Roadmap\n",
+  );
+}
+
+function cleanup(base: string, originalCwd: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { process.chdir(originalCwd); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("#4551: AutoSession.lastPreExecFailure defaults to null", () => {
+  const s = new AutoSession();
+  assert.equal(s.lastPreExecFailure, null, "lastPreExecFailure must start null");
+});
+
+test("#4551: AutoSession.reset() clears lastPreExecFailure", () => {
+  const s = new AutoSession();
+  s.lastPreExecFailure = {
+    unitId: "M001/S01",
+    blockingFindings: ["[file] src/foo.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+  s.reset();
+  assert.equal(s.lastPreExecFailure, null, "reset() must clear lastPreExecFailure");
+});
+
+test("#4551: buildPlanSlicePrompt injects fix section when priorPreExecFailure provided", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const prompt = await buildPlanSlicePrompt(
+    "M001", "Test Milestone", "S01", "Core Slice", base,
+    undefined,
+    {
+      priorPreExecFailure: {
+        blockingFindings: [
+          "[file] src/utils/helper.ts: file not found",
+          "[package] nonexistent-pkg: package not found on npm",
+        ],
+        verdictExcerpt: "status=fail; 2 blocking issues detected",
+      },
+    },
+  );
+
+  assert.ok(
+    prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must contain the fix section heading",
+  );
+  assert.ok(
+    prompt.includes("src/utils/helper.ts: file not found"),
+    "prompt must include the specific file finding",
+  );
+  assert.ok(
+    prompt.includes("nonexistent-pkg: package not found on npm"),
+    "prompt must include the specific package finding",
+  );
+  assert.ok(
+    prompt.includes("status=fail; 2 blocking issues detected"),
+    "prompt must include the verdict excerpt",
+  );
+});
+
+test("#4551: buildPlanSlicePrompt with no priorPreExecFailure does NOT include fix section", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const prompt = await buildPlanSlicePrompt(
+    "M001", "Test Milestone", "S01", "Core Slice", base,
+    undefined,
+    { /* no priorPreExecFailure */ },
+  );
+
+  assert.ok(
+    !prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must NOT include the fix section when no failure context is given",
+  );
+});
+
+test("#4551: dispatch rule injects failure context and clears session field", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  // Write a RESEARCH file so the dispatch rule skips research-slice and reaches
+  // plan-slice (which is the phase we're testing).
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+    "# Research\n",
+  );
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const state = await deriveStateFromDb(base);
+  assert.equal(state.phase, "planning", "state must be in planning phase");
+
+  const session = new AutoSession();
+  session.basePath = base;
+  session.active = true;
+  session.lastPreExecFailure = {
+    unitId: "M001/S01",
+    blockingFindings: ["[file] src/missing.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+
+  const ctx: DispatchContext = {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { phases: { reassess_after_slice: false, skip_research: true } } as any,
+    session,
+  };
+
+  const result = await resolveDispatch(ctx);
+  assert.equal(result.action, "dispatch", "must dispatch a unit");
+  if (result.action !== "dispatch") throw new Error("unreachable");
+  assert.equal(result.unitType, "plan-slice", "must be a plan-slice unit");
+
+  // The fix section must appear in the prompt
+  assert.ok(
+    result.prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "dispatched prompt must include the fix section",
+  );
+  assert.ok(
+    result.prompt.includes("src/missing.ts: file not found"),
+    "dispatched prompt must include the specific blocking finding",
+  );
+
+  // Field must be cleared after consumption
+  assert.equal(
+    session.lastPreExecFailure,
+    null,
+    "lastPreExecFailure must be cleared after being consumed by the dispatch rule",
+  );
+});
+
+test("#4551: dispatch rule does NOT inject stale failure for a different slice", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeTempBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedPlanningState(base);
+  // Write a RESEARCH file so dispatch reaches plan-slice, making the assertion
+  // about the prompt meaningful (we can check it's a plan-slice prompt without
+  // the fix section rather than a research-slice prompt without it).
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-RESEARCH.md"),
+    "# Research\n",
+  );
+  process.chdir(base);
+  _clearGsdRootCache();
+  invalidateAllCaches();
+
+  const state = await deriveStateFromDb(base);
+
+  const session = new AutoSession();
+  session.basePath = base;
+  session.active = true;
+  // Failure belongs to a different slice (S02), not the active one (S01)
+  session.lastPreExecFailure = {
+    unitId: "M001/S02",
+    blockingFindings: ["[file] src/other.ts: file not found"],
+    verdictExcerpt: "status=fail; 1 blocking issue detected",
+  };
+
+  const ctx: DispatchContext = {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test Milestone",
+    state,
+    prefs: { phases: { reassess_after_slice: false, skip_research: true } } as any,
+    session,
+  };
+
+  const result = await resolveDispatch(ctx);
+  assert.equal(result.action, "dispatch");
+  if (result.action !== "dispatch") throw new Error("unreachable");
+
+  // The stale fix section must NOT appear
+  assert.ok(
+    !result.prompt.includes("Fix these specific issues from the prior pre-exec check"),
+    "prompt must NOT include fix section for a mismatched unit ID",
+  );
+  assert.ok(
+    !result.prompt.includes("src/other.ts"),
+    "prompt must NOT include findings from a different slice",
+  );
+
+  // Field must remain untouched (not consumed)
+  assert.notEqual(
+    session.lastPreExecFailure,
+    null,
+    "lastPreExecFailure must NOT be cleared when unit IDs don't match",
+  );
+});