gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/complete-slice-composer.test.ts

@@ -0,0 +1,192 @@
+// GSD-2 — #4782 phase 3 batch 3: complete-slice migrated through composer.
+
+import test 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 { buildCompleteSlicePrompt } from "../auto-prompts.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-completeslice-composer-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function seed(base: string, mid: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: mid, title: "Composer Test", status: "active", depends_on: [] });
+  upsertMilestonePlanning(mid, {
+    title: "Composer Test",
+    status: "active",
+    vision: "Validate complete-slice migration",
+    successCriteria: ["Prompt compiles"],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: mid,
+    title: "First",
+    status: "complete",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: mid,
+    title: "Task one",
+    status: "complete",
+  });
+}
+
+function writeArtifacts(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# M001 Roadmap\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    "# S01 Plan\n\nSlice plan body.\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    "---\nid: T01\n---\n# T01 Summary\n\nTask one did the thing.\n",
+  );
+}
+
+test("#4782 phase 3: buildCompleteSlicePrompt composes roadmap → plan → task summaries → templates in declared order", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+
+  const prompt = await buildCompleteSlicePrompt("M001", "Composer Test", "S01", "First", base);
+
+  // Context wrapper present
+  assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+
+  // Manifest-declared artifacts present
+  assert.match(prompt, /### Milestone Roadmap/);
+  assert.match(prompt, /### Slice Plan/);
+  assert.match(prompt, /### Task Summary: T01/);
+  assert.match(prompt, /### Output Template: Slice Summary/);
+
+  // Ordering: roadmap → slice plan → task summaries → slice summary template
+  const roadmapIdx = prompt.indexOf("### Milestone Roadmap");
+  const planIdx = prompt.indexOf("### Slice Plan");
+  const taskSummaryIdx = prompt.indexOf("### Task Summary: T01");
+  const sliceSummaryTemplateIdx = prompt.indexOf("### Output Template: Slice Summary");
+
+  assert.ok(roadmapIdx > -1 && planIdx > roadmapIdx, "roadmap precedes slice plan");
+  assert.ok(planIdx > -1 && taskSummaryIdx > planIdx, "slice plan precedes task summaries");
+  assert.ok(
+    taskSummaryIdx > -1 && sliceSummaryTemplateIdx > taskSummaryIdx,
+    "task summaries precede slice-summary template",
+  );
+
+  // Task body inlined
+  assert.match(prompt, /Task one did the thing/);
+});
+
+test("#4782 phase 3: buildCompleteSlicePrompt handles missing task summaries gracefully", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  // Write roadmap + plan but no task summaries
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# M001 Roadmap\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    "# S01 Plan\n",
+  );
+
+  const prompt = await buildCompleteSlicePrompt("M001", "Composer Test", "S01", "First", base);
+
+  // Still succeeds — prior-task-summaries resolver returns null when dir is empty
+  assert.match(prompt, /### Milestone Roadmap/);
+  assert.match(prompt, /### Slice Plan/);
+  // No task summary blocks — they'd have a "### Task Summary:" prefix
+  assert.ok(!prompt.includes("### Task Summary:"));
+  // Roadmap still precedes slice plan despite the missing block
+  const roadmapIdx = prompt.indexOf("### Milestone Roadmap");
+  const planIdx = prompt.indexOf("### Slice Plan");
+  assert.ok(roadmapIdx > -1 && planIdx > roadmapIdx);
+});
+
+test("#4925 review: KNOWLEDGE splices BEFORE templates when no task summaries exist", async (t) => {
+  // Regression for the bug fixed in fcf3bfbe: the templates fallback was
+  // searching for "### Slice Summary" but inlineTemplate emits
+  // "### Output Template: Slice Summary", so templatesIdx stayed -1 and
+  // knowledge ended up appended after templates instead of before them.
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  // Roadmap + plan only — no T*-SUMMARY.md, so taskIdx must be -1 and the
+  // splice falls through to the templates anchor.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# M001 Roadmap\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    "# S01 Plan\n",
+  );
+  // KNOWLEDGE.md with an H3 section whose header matches the slice title
+  // keyword "first" — queryKnowledge will return the section, so
+  // inlineKnowledgeBudgeted produces a non-null block and the splice
+  // path executes.
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "KNOWLEDGE.md"),
+    "## Topics\n\n### First-slice notes\n\nNotes that should be inlined.\n",
+  );
+
+  const prompt = await buildCompleteSlicePrompt("M001", "Composer Test", "S01", "First", base);
+
+  // Sanity: the splice path actually fired.
+  assert.ok(!prompt.includes("### Task Summary:"), "fixture must have no task summaries to exercise the fallback");
+  const knowledgeIdx = prompt.indexOf("### Project Knowledge (scoped)");
+  const templatesIdx = prompt.indexOf("### Output Template: Slice Summary");
+  assert.ok(knowledgeIdx > -1, "knowledge block missing — fixture failed to populate KNOWLEDGE.md scope");
+  assert.ok(templatesIdx > -1, "templates block missing");
+  // The bug: knowledge appeared AFTER templates. The fix: knowledge before templates.
+  assert.ok(
+    knowledgeIdx < templatesIdx,
+    `knowledge (${knowledgeIdx}) must splice before templates (${templatesIdx}) when no task summaries exist`,
+  );
+});

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -11,6 +11,7 @@ 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', 'tools', 'complete-slice.ts'),
@@ -59,7 +60,7 @@ describe('complete-slice verification gate (#3580)', () => {
     const gateIdx = src.indexOf('BLOCKED_SIGNALS.test(')
     assert.ok(gateIdx !== -1)
 
-    const afterGate = src.slice(gateIdx, gateIdx + 500)
+    const afterGate = extractSourceRegion(src, 'BLOCKED_SIGNALS.test(')
     assert.ok(
       afterGate.includes('return { error:'),
       'blocked signal detection must return an error',

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -14,6 +14,7 @@ import {
   getTask,
   getSliceTasks,
   insertVerificationEvidence,
+  SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteTask } from '../tools/complete-task.ts';
 
@@ -99,19 +100,22 @@ function makeValidParams() {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// complete-task: Schema v5 migration
+// complete-task: Fresh DB is migrated to the current schema version
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== complete-task: schema v5 migration ===');
+console.log('\n=== complete-task: fresh DB migrates to current schema version ===');
 {
   const dbPath = tempDbPath();
   openDatabase(dbPath);
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v22 — quality_gates DDL fix)
+  // Verify schema version matches the current source-of-truth constant.
+  // Asserting against SCHEMA_VERSION (not a hardcoded number) keeps this
+  // green across migration bumps while still catching a
+  // "fresh-DB-was-not-migrated" regression.
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 22, 'schema version should be 22');
+  assertEq(versionRow?.['v'], SCHEMA_VERSION, 'fresh DB should be migrated to current SCHEMA_VERSION');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(
@@ -399,9 +403,12 @@ console.log('\n=== complete-task: handler idempotency ===');
   const r1 = await handleCompleteTask(params, basePath);
   assertTrue(!('error' in r1), 'first call should succeed');
 
-  // Verify only 1 task row
+  // Verify complete-task did not duplicate T01. State reconciliation may import
+  // the remaining plan task from disk so the DB stays aligned with S01-PLAN.md.
   const tasks = getSliceTasks('M001', 'S01');
-  assertEq(tasks.length, 1, 'should have exactly 1 task row after first call');
+  assertEq(tasks.length, 2, 'should have T01 plus reconciled T02 after first call');
+  assertEq(tasks.filter(t => t.id === 'T01').length, 1, 'should have exactly one T01 row after first call');
+  assertEq(tasks.find(t => t.id === 'T02')?.status, 'pending', 'T02 should be reconciled as pending');
 
   // Second call with same params — state machine guard rejects (task is already complete)
   const r2 = await handleCompleteTask(params, basePath);
@@ -410,9 +417,10 @@ console.log('\n=== complete-task: handler idempotency ===');
     assertMatch(r2.error, /already complete/, 'error should mention already complete');
   }
 
-  // Still only 1 task row (no duplication from rejected second call)
+  // Still no duplicate rows from the rejected second call.
   const tasksAfter = getSliceTasks('M001', 'S01');
-  assertEq(tasksAfter.length, 1, 'should still have exactly 1 task row after rejected second call');
+  assertEq(tasksAfter.length, 2, 'should still have T01 plus reconciled T02 after rejected second call');
+  assertEq(tasksAfter.filter(t => t.id === 'T01').length, 1, 'should still have exactly one T01 row');
 
   cleanupDir(basePath);
   cleanup(dbPath);