gsd-pi 2.77.0 → 2.78.0

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Worker × Skill × Subagent — prompt composition integration test.
+ *
+ * Covers two previously-untested seams:
+ *
+ *  P1. Worker × Skill — when a parallel worker's auto loop reaches a
+ *      research/plan/execute unit, the prompt it receives must include the
+ *      `<skill_activation>` block derived from the project's PREFERENCES.md.
+ *      `buildSkillActivationBlock` is unit-tested in isolation; here we
+ *      verify a dispatch-level builder actually plumbs it through.
+ *
+ *  P2. Subagent × Skill — when `buildParallelResearchSlicesPrompt` composes
+ *      per-slice subagent prompts, each embedded prompt must also carry the
+ *      `<skill_activation>` block so the dispatched subagent inherits it.
+ */
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadSkills } from "@gsd/pi-coding-agent";
+import {
+  buildResearchSlicePrompt,
+  buildParallelResearchSlicesPrompt,
+} from "../auto-prompts.ts";
+
+const SKILL_NAME = "testskill";
+const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
+
+const tmpDirs: string[] = [];
+let savedCwd: string | undefined;
+
+function setupProjectWithSkill(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worker-skill-int-"));
+  tmpDirs.push(base);
+
+  // Milestone roadmap — buildResearchSlicePrompt inlines the roadmap excerpt.
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+  mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "**Vision:** Verify worker × skill prompt plumbing.",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+      "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Project preferences — buildSkillActivationBlock picks these up via
+  // loadEffectiveGSDPreferences(), which reads from `${cwd}/.gsd/PREFERENCES.md`.
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    ["---", `always_use_skills:`, `  - ${SKILL_NAME}`, "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  // Project-scoped skill — resolveSkillReference scans `${cwd}/.agents/skills/`.
+  const skillDir = join(base, ".agents", "skills", SKILL_NAME);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    join(skillDir, "SKILL.md"),
+    [
+      "---",
+      `name: ${SKILL_NAME}`,
+      `description: Integration-test skill for worker × skill prompt plumbing.`,
+      "---",
+      "",
+      `# ${SKILL_NAME}`,
+      "",
+      "Test skill body.",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Load this skill into the in-process skill registry so
+  // buildSkillActivationBlock treats it as "installed".
+  loadSkills({
+    cwd: base,
+    includeDefaults: false,
+    skillPaths: [join(base, ".agents", "skills")],
+  });
+
+  return base;
+}
+
+afterEach(() => {
+  if (savedCwd !== undefined) {
+    try { process.chdir(savedCwd); } catch { /* best-effort */ }
+    savedCwd = undefined;
+  }
+  for (const dir of tmpDirs) {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  }
+  tmpDirs.length = 0;
+});
+
+test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from PREFERENCES.md", async () => {
+  const base = setupProjectWithSkill();
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildResearchSlicePrompt("M001", "Test Milestone", "S01", "Alpha", base);
+
+  assert.ok(
+    prompt.includes("<skill_activation>"),
+    "research-slice prompt should contain a <skill_activation> block",
+  );
+  assert.ok(
+    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
+  );
+});
+
+test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skill_activation> into each embedded per-slice section", async () => {
+  const base = setupProjectWithSkill();
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildParallelResearchSlicesPrompt(
+    "M001",
+    "Test Milestone",
+    [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ],
+    base,
+  );
+
+  // The parallel dispatch prompt concatenates per-slice subagent prompts inside
+  // fenced code blocks. Each block should carry the same skill activation.
+  const blockCount = (prompt.match(/<skill_activation>/g) ?? []).length;
+  assert.ok(
+    blockCount >= 2,
+    `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
+  );
+  assert.ok(
+    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
+  );
+});

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/pre-execution-pause-wiring.test.ts

@@ -191,7 +191,12 @@ function createFailingTasks(): void {
       estimate: "1h",
       files: [],
       verify: "npm test",
-      inputs: ["nonexistent-file-that-does-not-exist.ts"],
+      inputs: [
+        "nonexistent-file-that-does-not-exist.ts",
+        "missing-second-file.ts",
+        "missing-third-file.ts",
+        "missing-fourth-file.ts",
+      ],
       expectedOutput: [],
       observabilityImpact: "",
     },
@@ -308,6 +313,32 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
         String(call.arguments[0]).includes("Pre-execution checks failed")
     );
     assert.ok(errorNotify, "Should show error notification about pre-execution check failure");
+    const errorMessage = String(errorNotify.arguments[0]);
+    assert.match(
+      errorMessage,
+      /Pre-execution checks failed: \d+ blocking issue/,
+      "failure notification should include the blocking issue count",
+    );
+    assert.ok(
+      errorMessage.includes("[file] nonexistent-file-that-does-not-exist.ts: Task T01 references"),
+      "failure notification should include category, target, and message details",
+    );
+    assert.ok(
+      errorMessage.includes("[file] missing-third-file.ts: Task T01 references"),
+      "failure notification should include up to three actionable check details",
+    );
+    assert.ok(
+      !errorMessage.includes("missing-fourth-file.ts"),
+      "failure notification should truncate details beyond the display limit",
+    );
+    assert.ok(
+      errorMessage.includes("...and 1 more"),
+      "failure notification should summarize truncated blocking checks",
+    );
+    assert.ok(
+      errorMessage.includes(join(".gsd", "milestones", "M001", "slices", "S01", "S01-PRE-EXEC-VERIFY.json")),
+      "failure notification should point to the relative pre-exec evidence file path",
+    );
   });
 
   test("pauseAuto is called when enhanced_verification_strict: true and pre-execution returns warn", async () => {

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -12,6 +12,7 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
@@ -49,7 +50,7 @@ test("copyPlanningArtifacts prefers canonical PREFERENCES.md with lowercase fall
   assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
 
   // Extract function body (up to the next top-level function)
-  const fnBody = src.slice(fnIdx, fnIdx + 2200);
+  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
 
   assert.ok(
     fnBody.includes("PROJECT_PREFERENCES_FILE") && fnBody.includes("LEGACY_PROJECT_PREFERENCES_FILE"),

package/src/resources/extensions/gsd/tests/prompt-cache-optimizer.test.ts

@@ -64,6 +64,18 @@ describe("prompt-cache-optimizer: classifySection", () => {
     assert.equal(classifySection("overrides"), "semi-static");
   });
 
+  // Regression: issue #4719 — KNOWLEDGE falls through to dynamic default.
+  // Knowledge content is reused across all tasks within a milestone, so it
+  // must be classified as semi-static to qualify for prefix caching when the
+  // cache optimizer is wired into the prompt path.
+  it("classifies knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("knowledge"), "semi-static");
+  });
+
+  it("classifies project-knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("project-knowledge"), "semi-static");
+  });
+
   it("classifies task-plan as dynamic", () => {
     assert.equal(classifySection("task-plan"), "dynamic");
   });

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -13,6 +13,7 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -69,11 +70,21 @@ describe('register-extension _gsdEpipeGuard (#3696)', () => {
 
 describe('register-hooks session_before_compact (#3696)', () => {
   test('session_before_compact only checks isAutoActive', () => {
-    // Extract the session_before_compact handler
-    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
+    // Anchor on the full registration token rather than the bare event name —
+    // prevents matching unrelated substring occurrences.
+    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
     assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
-    // The first check in the handler should be isAutoActive(), not isAutoPaused()
-    const afterCompact = registerHooksSrc.slice(compactIdx, compactIdx + 300);
+    // The first check in the handler should be isAutoActive(), not isAutoPaused().
+    // Bound the region to this single handler — register-hooks.ts contains
+    // multiple pi.on("session_before_compact") handlers and a later handler
+    // legitimately references isAutoPaused.
+    const afterCompact = extractSourceRegion(
+      registerHooksSrc,
+      'pi.on("session_before_compact"',
+      'pi.on("',
+      // NB: endAnchor search starts AFTER the startAnchor, so the next
+      // pi.on("... matches the subsequent handler rather than this one.
+    );
     assert.match(afterCompact, /isAutoActive\(\)/,
       'session_before_compact should check isAutoActive()');
     // Should NOT block compaction when paused