gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -7,9 +7,10 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
 
 import {
   _getPendingAutoStart,
@@ -17,6 +18,17 @@ import {
   setPendingAutoStart,
 } from "../guided-flow.ts";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  };
+}
+
 afterEach(() => {
   clearPendingAutoStart();
 });
@@ -28,7 +40,7 @@ describe("clear stale pending auto-start (#3667)", () => {
     mkdirSync(join(base, ".gsd"), { recursive: true });
     const before = Date.now();
 
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry);
@@ -41,8 +53,24 @@ describe("clear stale pending auto-start (#3667)", () => {
     t.after(() => rmSync(base, { recursive: true, force: true }));
     mkdirSync(join(base, ".gsd"), { recursive: true });
 
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", createdAt: 123 });
+    setPendingAutoStart(base, { ...pendingInput(base, "M001"), createdAt: 123 });
 
     assert.equal(_getPendingAutoStart(base)?.createdAt, 123);
   });
+
+  test("guided-flow clears stale pending entry when discuss already completed", () => {
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes('const milestoneHasRoadmap = !!resolveMilestoneFile(basePath, entry.milestoneId, "ROADMAP");'),
+      "pending auto-start gate must check ROADMAP presence for completed discuss sessions",
+    );
+    assert.ok(
+      source.includes('milestoneRow.status !== "queued"'),
+      "pending auto-start gate must require non-queued DB milestone status before clearing",
+    );
+    assert.ok(
+      source.includes("if (discussPlanComplete)"),
+      "pending auto-start gate must clear stale map entries for completed discussions",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/closeout-git-deferral.test.ts

@@ -0,0 +1,16 @@
+// Project/App: GSD-2
+// File Purpose: Tests closeout git action deferral policy for auto-mode units.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldDeferCloseoutGitAction } from "../auto-post-unit.ts";
+
+test("execute-task defers closeout git action until verification passes", () => {
+  assert.equal(shouldDeferCloseoutGitAction("execute-task"), true);
+});
+
+test("non execute-task units keep pre-verification closeout git action", () => {
+  assert.equal(shouldDeferCloseoutGitAction("plan-slice"), false);
+  assert.equal(shouldDeferCloseoutGitAction("complete-slice"), false);
+});

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -0,0 +1,378 @@
+/**
+ * Tests for /gsd verdict — manual override of milestone validation verdict.
+ *
+ * Covers parseValidationFile section extraction and handleVerdict end-to-end:
+ * pass override, needs-remediation override with rationale, missing rationale
+ * rejection, active-milestone fallback, missing VALIDATION rejection.
+ *
+ * Also asserts the three paused-state messages reference /gsd verdict so the
+ * user has a discoverable recovery path.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { handleVerdict, parseValidationFile } from "../commands-verdict.ts";
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
+
+interface NotifyCall {
+  message: string;
+  kind: string;
+}
+
+function makeMockCtx(): { ctx: any; calls: NotifyCall[] } {
+  const calls: NotifyCall[] = [];
+  const ctx = {
+    ui: {
+      notify: (message: string, kind: string) => {
+        calls.push({ message, kind });
+      },
+    },
+  };
+  return { ctx, calls };
+}
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-verdict-${randomUUID()}-`));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* swallow */ }
+}
+
+function openTestDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+function seedMilestone(milestoneId: string, title: string, status = "active"): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)",
+  ).run(milestoneId, title, status, new Date().toISOString());
+}
+
+function seedSlice(milestoneId: string, sliceId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO slices (milestone_id, id, title, status, created_at) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, `Slice ${sliceId}`, status, new Date().toISOString());
+}
+
+function writeValidation(base: string, milestoneId: string, verdict: string, round = 0): string {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(milestoneDir, { recursive: true });
+  const path = join(milestoneDir, `${milestoneId}-VALIDATION.md`);
+  const md = [
+    "---",
+    `verdict: ${verdict}`,
+    `remediation_round: ${round}`,
+    "---",
+    "",
+    `# Milestone Validation: ${milestoneId}`,
+    "",
+    "## Success Criteria Checklist",
+    "- [x] Criterion A met",
+    "- [x] Criterion B met",
+    "",
+    "## Slice Delivery Audit",
+    "| Slice | Result |",
+    "| --- | --- |",
+    "| S01 | delivered |",
+    "",
+    "## Cross-Slice Integration",
+    "No cross-slice mismatches detected.",
+    "",
+    "## Requirement Coverage",
+    "All requirements covered.",
+    "",
+    "## Verdict Rationale",
+    `Initial verdict was ${verdict}.`,
+    "",
+  ].join("\n");
+  writeFileSync(path, md);
+  return path;
+}
+
+// ─── parseValidationFile ────────────────────────────────────────────────
+
+test("parseValidationFile extracts all standard sections and frontmatter", () => {
+  const md = [
+    "---",
+    "verdict: needs-attention",
+    "remediation_round: 2",
+    "---",
+    "",
+    "# Milestone Validation: M001",
+    "",
+    "## Success Criteria Checklist",
+    "- [x] First",
+    "- [ ] Second",
+    "",
+    "## Slice Delivery Audit",
+    "| Slice | Delivered |",
+    "",
+    "## Cross-Slice Integration",
+    "Boundary intact.",
+    "",
+    "## Requirement Coverage",
+    "R001 covered.",
+    "",
+    "## Verification Class Compliance",
+    "Operational: MET",
+    "",
+    "## Verdict Rationale",
+    "Acceptance proof incomplete.",
+    "",
+    "## Remediation Plan",
+    "Address acceptance proof.",
+    "",
+  ].join("\n");
+
+  const parsed = parseValidationFile(md);
+
+  assert.equal(parsed.verdict, "needs-attention");
+  assert.equal(parsed.remediationRound, 2);
+  assert.match(parsed.successCriteriaChecklist, /First/);
+  assert.match(parsed.successCriteriaChecklist, /Second/);
+  assert.match(parsed.sliceDeliveryAudit, /Delivered/);
+  assert.match(parsed.crossSliceIntegration, /Boundary intact/);
+  assert.match(parsed.requirementCoverage, /R001 covered/);
+  assert.match(parsed.verificationClasses ?? "", /Operational: MET/);
+  assert.match(parsed.verdictRationale, /Acceptance proof incomplete/);
+  assert.match(parsed.remediationPlan ?? "", /Address acceptance proof/);
+});
+
+test("parseValidationFile omits optional sections when absent", () => {
+  const md = [
+    "---",
+    "verdict: pass",
+    "remediation_round: 0",
+    "---",
+    "",
+    "## Success Criteria Checklist",
+    "- [x] All met",
+    "",
+    "## Slice Delivery Audit",
+    "Done.",
+    "",
+    "## Cross-Slice Integration",
+    "Clean.",
+    "",
+    "## Requirement Coverage",
+    "Complete.",
+    "",
+    "## Verdict Rationale",
+    "All criteria met.",
+  ].join("\n");
+
+  const parsed = parseValidationFile(md);
+
+  assert.equal(parsed.verdict, "pass");
+  assert.equal(parsed.remediationRound, 0);
+  assert.equal(parsed.verificationClasses, undefined);
+  assert.equal(parsed.remediationPlan, undefined);
+});
+
+// ─── handleVerdict — argument validation ────────────────────────────────
+
+test("handleVerdict rejects missing verdict", async () => {
+  const { ctx, calls } = makeMockCtx();
+  await handleVerdict("", ctx, "/tmp/unused");
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /Usage: \/gsd verdict/);
+  assert.equal(calls[0].kind, "warning");
+});
+
+test("handleVerdict rejects invalid verdict", async () => {
+  const { ctx, calls } = makeMockCtx();
+  await handleVerdict("yolo", ctx, "/tmp/unused");
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].message, /Invalid verdict "yolo"/);
+  assert.equal(calls[0].kind, "warning");
+});
+
+test("handleVerdict rejects needs-remediation without --rationale", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    writeValidation(base, "M001", "pass");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("needs-remediation --milestone M001", ctx, base);
+
+    assert.ok(
+      calls.some((c) => /--rationale is required/.test(c.message)),
+      `expected rationale-required warning, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict rejects when VALIDATION file is missing", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    assert.ok(
+      calls.some((c) => /No VALIDATION file found/.test(c.message)),
+      `expected missing-VALIDATION warning, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+// ─── handleVerdict — pass override flow ─────────────────────────────────
+
+test("handleVerdict pass override flips verdict and preserves sections", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    const validationPath = writeValidation(base, "M001", "needs-attention");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: pass$/m, "verdict should flip to pass");
+    assert.match(rewritten, /Criterion A met/, "success criteria preserved");
+    assert.match(rewritten, /S01 \| delivered/, "slice audit preserved");
+    assert.match(rewritten, /Manually overridden via \/gsd verdict/, "default rationale applied");
+
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /needs-attention.*->.*pass/.test(c.message)),
+      `expected success notification, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict needs-remediation override with --rationale rewrites verdict", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    const validationPath = writeValidation(base, "M001", "pass");
+
+    const { ctx, calls } = makeMockCtx();
+    await handleVerdict(
+      'needs-remediation --milestone M001 --rationale "found missing slice"',
+      ctx,
+      base,
+    );
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: needs-remediation$/m);
+    assert.match(rewritten, /found missing slice/);
+
+    assert.ok(
+      calls.some((c) => /gsd_reassess_roadmap/.test(c.message)),
+      "needs-remediation override should suggest gsd_reassess_roadmap follow-up",
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+test("handleVerdict resolves active milestone when --milestone omitted", async () => {
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M042", "Active Milestone");
+    seedSlice("M042", "S01", "complete");
+    const validationPath = writeValidation(base, "M042", "needs-attention");
+
+    const { ctx, calls } = makeMockCtx();
+    invalidateStateCache();
+    await handleVerdict("pass", ctx, base);
+
+    const rewritten = readFileSync(validationPath, "utf-8");
+    assert.match(rewritten, /^verdict: pass$/m);
+    assert.ok(
+      calls.some((c) => c.kind === "success" && /M042/.test(c.message)),
+      `expected success notification naming M042, got: ${JSON.stringify(calls)}`,
+    );
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});
+
+// ─── Pause messages reference /gsd verdict ─────────────────────────────
+
+test("auto-dispatch needs-attention pause message references /gsd verdict", async () => {
+  const { DISPATCH_RULES } = await import("../auto-dispatch.ts");
+  const rule = DISPATCH_RULES.find((r) => r.name === "completing-milestone → complete-milestone");
+  assert.ok(rule, "completing-milestone rule should exist");
+
+  const base = mkdtempSync(join(tmpdir(), "gsd-verdict-paused-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds work.\n",
+    );
+
+    const result = await rule!.match({
+      mid: "M001",
+      midTitle: "Test",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    } as any);
+
+    assert.ok(result !== null);
+    assert.equal(result!.action, "stop");
+    if (result!.action === "stop") {
+      assert.match(result!.reason, /\/gsd verdict/);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("state.ts needs-remediation blocker messages reference /gsd verdict", async () => {
+  // We don't need to invoke deriveState — just assert the substring is in the
+  // source. The blocker strings are constructed inline and shipped to the user
+  // verbatim, so a static check is sufficient and avoids fragile DB setup.
+  const stateSource = readFileSync(
+    new URL("../state.ts", import.meta.url).pathname,
+    "utf-8",
+  );
+  const occurrences = stateSource.match(/`\/gsd verdict /g) ?? [];
+  assert.ok(
+    occurrences.length >= 2,
+    `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
+  );
+});

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

@@ -7,7 +7,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { invalidateAllCaches } from '../cache.ts';
 import { parseUnitId } from "../unit-id.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, insertAssessment } from "../gsd-db.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
 
@@ -503,6 +503,49 @@ describe("complete-milestone", () => {
     }
   });
 
+  test("handleCompleteMilestone refuses closeout when latest validation verdict is needs-attention (#5661)", async () => {
+    const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
+    const base = createFixtureBase();
+    const mid = "M001";
+    const dbPath = join(base, ".gsd", "gsd.db");
+    try {
+      openDatabase(dbPath);
+      insertMilestone({ id: mid, title: "Test Milestone", status: "active" });
+      insertSlice({ id: "S01", milestoneId: mid, title: "Slice One", status: "complete" });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task One", status: "complete" });
+      insertAssessment({
+        path: join(".gsd", "milestones", mid, `${mid}-VALIDATION.md`),
+        milestoneId: mid,
+        status: "needs-attention",
+        scope: "milestone-validation",
+        fullContent: "---\nverdict: needs-attention\nremediation_round: 1\n---\n\n# Validation\nNeeds attention.",
+      });
+
+      const result = await handleCompleteMilestone({
+        milestoneId: mid,
+        title: "Test Milestone",
+        oneLiner: "Test",
+        narrative: "Test narrative",
+        successCriteriaResults: "Results",
+        definitionOfDoneResults: "Done",
+        requirementOutcomes: "Outcomes",
+        keyDecisions: [],
+        keyFiles: [],
+        lessonsLearned: [],
+        followUps: "",
+        deviations: "",
+        verificationPassed: true,
+      }, base);
+
+      assert.ok("error" in result, "non-pass validation verdict should block completion");
+      assert.match((result as { error: string }).error, /needs-attention/i);
+      assert.match((result as { error: string }).error, /Only verdict=pass permits closeout/i);
+    } finally {
+      try { closeDatabase(); } catch { /* */ }
+      cleanup(base);
+    }
+  });
+
   test("deriveState completing-milestone integration", async () => {
     const { deriveState, isMilestoneComplete } = await import("../state.ts");
     const { invalidateAllCaches: invalidateAllCachesDynamic } = await import("../cache.ts");
@@ -645,7 +688,7 @@ describe("complete-milestone", () => {
     assert.strictEqual(sanitized.triggerReason, undefined);
   });
 
-  test("rendered SUMMARY.md uses placeholder text for empty enrichment fields", async () => {
+  test("rendered SUMMARY.md uses empty frontmatter lists for empty key fields", async () => {
     const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
     const base = createFixtureBase();
     const mid = "M001";
@@ -655,6 +698,13 @@ describe("complete-milestone", () => {
       insertMilestone({ id: mid, title: "Empty Enrichment", status: "active" });
       insertSlice({ id: "S01", milestoneId: mid, title: "Slice", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task", status: "complete" });
+      insertAssessment({
+        path: join(".gsd", "milestones", mid, `${mid}-VALIDATION.md`),
+        milestoneId: mid,
+        status: "pass",
+        scope: "milestone-validation",
+        fullContent: "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nValidated.",
+      });
 
       const result = await handleCompleteMilestone({
         milestoneId: mid,
@@ -678,6 +728,9 @@ describe("complete-milestone", () => {
       assert.match(summary, /## Success Criteria Results\n\nNot provided\./);
       assert.match(summary, /## Definition of Done Results\n\nNot provided\./);
       assert.match(summary, /## Requirement Outcomes\n\nNot provided\./);
+      assert.match(summary, /key_decisions:\s*\[\]/);
+      assert.match(summary, /key_files:\s*\[\]/);
+      assert.doesNotMatch(summary, /key_(?:decisions|files):\n  - \(none\)/);
       assert.match(summary, /## Deviations\n\nNone\./);
       assert.match(summary, /## Follow-ups\n\nNone\./);
     } finally {

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

@@ -13,6 +13,7 @@ import {
   getSlice,
   updateSliceStatus,
   getSliceTasks,
+  setSliceSummaryMd,
   SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteSlice } from '../tools/complete-slice.ts';
@@ -408,10 +409,64 @@ console.log('\n=== complete-slice: handler with missing roadmap ===');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// complete-slice: step 13 specifies write tool for PROJECT.md (#2946)
+// complete-slice: backfills omitted requirements from rendered summary
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== complete-slice: step 13 specifies write tool for PROJECT.md (#2946) ===');
+console.log('\n=== complete-slice: backfills omitted requirements from rendered summary ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001' });
+  insertSlice({ id: 'S01', milestoneId: 'M001' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
+
+  const seedParams = makeValidSliceParams();
+  const seeded = await handleCompleteSlice(seedParams, basePath);
+  assertTrue(!('error' in seeded), 'seed completion should succeed');
+  if ('error' in seeded) {
+    cleanupDir(basePath);
+    cleanup(dbPath);
+    throw new Error('seed completion unexpectedly failed');
+  }
+
+  const seededSummary = fs.readFileSync(seeded.summaryPath, 'utf-8');
+  transaction(() => {
+    updateSliceStatus('M001', 'S01', 'pending', undefined);
+    setSliceSummaryMd('M001', 'S01', seededSummary, '');
+  });
+
+  const backfillParams = makeValidSliceParams();
+  delete (backfillParams as Partial<CompleteSliceParams>).requirementsAdvanced;
+  delete (backfillParams as Partial<CompleteSliceParams>).requirementsValidated;
+  delete (backfillParams as Partial<CompleteSliceParams>).requirementsInvalidated;
+  const backfilled = await handleCompleteSlice(backfillParams as CompleteSliceParams, basePath);
+  assertTrue(!('error' in backfilled), 'backfill completion should succeed');
+  if (!('error' in backfilled)) {
+    const summary = fs.readFileSync(backfilled.summaryPath, 'utf-8');
+    assertMatch(summary, /## Requirements Advanced/, 'summary should include advanced requirements heading');
+    assertMatch(summary, /- R001 — Handler validates task completion/, 'advanced requirement should be backfilled from summary markdown');
+
+    const sliceAfterBackfill = getSlice('M001', 'S01');
+    assertTrue(sliceAfterBackfill !== null, 'slice should exist after backfill');
+    assertMatch(
+      sliceAfterBackfill!.full_summary_md,
+      /- R001 — Handler validates task completion/,
+      'DB full_summary_md should persist the backfilled advanced requirement',
+    );
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-slice: PROJECT refresh uses DB-backed artifact tool.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-slice: PROJECT refresh uses gsd_summary_save ===');
 {
   const promptPath = path.join(
     path.dirname(new URL(import.meta.url).pathname),
@@ -419,13 +474,9 @@ console.log('\n=== complete-slice: step 13 specifies write tool for PROJECT.md (
   );
   const prompt = fs.readFileSync(promptPath, 'utf-8');
 
-  // Step 13 must explicitly name the `write` tool so the LLM doesn't
-  // confuse it with `edit` (which requires path + oldText + newText).
-  // See: https://github.com/gsd-build/gsd-2/issues/2946
-  const mentionsWriteTool =
-    /PROJECT\.md.*\bwrite\b/i.test(prompt) ||
-    /\bwrite\b.*PROJECT\.md/i.test(prompt);
-  assertTrue(mentionsWriteTool, 'step 13 must name the `write` tool when updating PROJECT.md');
+  assertTrue(prompt.includes('gsd_summary_save'), 'PROJECT refresh must use gsd_summary_save');
+  assertTrue(prompt.includes('artifact_type: "PROJECT"'), 'PROJECT refresh must use artifact_type PROJECT');
+  assertTrue(!/with a full `write`/i.test(prompt), 'prompt must not instruct direct PROJECT.md writes');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -491,7 +491,9 @@ console.log('\n=== complete-task: minimal params (no keyFiles, keyDecisions, ver
     assertTrue(fs.existsSync(result.summaryPath), 'summary file should be written with minimal params');
     const summaryContent = fs.readFileSync(result.summaryPath, 'utf-8');
     assertMatch(summaryContent, /blocker_discovered:\s*false/, 'blocker_discovered should default to false');
-    assertMatch(summaryContent, /\(none\)/, 'key_files/key_decisions should show (none) placeholder');
+    assertMatch(summaryContent, /key_files:\s*\[\]/, 'key_files should render as an empty frontmatter list');
+    assertMatch(summaryContent, /key_decisions:\s*\[\]/, 'key_decisions should render as an empty frontmatter list');
+    assertTrue(!summaryContent.includes('  - (none)'), 'empty frontmatter lists should not render (none) as a list item');
   }
 
   cleanupDir(basePath);