gsd-pi 2.82.0-dev.ed17d078d → 3.0.0

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -8,7 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -208,8 +208,8 @@ test("postflightPopStash conflict warning names the exact stash ref", () => {
     assert.match(postflight.message, /failed after merge of milestone M005C/);
 
     const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
-    assert.match(warning, /git stash pop stash@\{\d+\}/);
     assert.match(warning, /git stash apply stash@\{\d+\}/);
+    assert.match(warning, /git stash drop stash@\{\d+\}/);
   } finally {
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
@@ -279,3 +279,108 @@ test("postflightPopStash falls back to milestone marker prefix when exact marker
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
 });
+
+test("postflightPopStash preserves stash when untracked collision differs from merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local preflight test\n");
+    const preflight = preflightCleanRoot(repo, "M009", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const postflight = postflightPopStash(repo, "M009", preflight.stashMarker, (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(postflight.needsManualRecovery, false, "different already-present untracked files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-preserved");
+    assert.deepEqual(postflight.collidedPaths, ["tests.txt"]);
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "merged milestone test\n");
+    assert.equal(run("git status --porcelain", repo), "", "merged file must stay clean");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash backup must be preserved");
+    assert.ok(
+      notifications.some((n) => n.level === "warning" && n.msg.includes("preserving")),
+      "user must be warned that the stash was preserved as backup",
+    );
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash drops stash when untracked collision is identical to merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    const preflight = preflightCleanRoot(repo, "M010", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add same test"', repo);
+
+    const postflight = postflightPopStash(repo, "M010", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, false, "identical already-present files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-dropped");
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "same test content\n");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(!stashList.includes(preflight.stashMarker ?? ""), "identical stash must be dropped");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery for mixed tracked changes and untracked collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# local tracked work\n");
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M011", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash mixed changes");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M011", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "tracked stash payload must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "mixed stash must be preserved");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery when an untracked stash path is missing after collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    writeFileSync(join(repo, "other-tests.txt"), "other local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M012", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked files");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add one merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M012", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "partial untracked restores must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    assert.equal(existsSync(join(repo, "other-tests.txt")), true, "git may partially restore the non-colliding path");
+    assert.match(run("git status --porcelain", repo), /\?\? other-tests\.txt/, "partial restore must leave manual recovery visible");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash must remain for manual recovery");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

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

@@ -17,6 +17,15 @@ import {
   setPendingAutoStart,
 } from "../guided-flow.ts";
 
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  };
+}
+
 afterEach(() => {
   clearPendingAutoStart();
 });
@@ -28,7 +37,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,7 +50,7 @@ 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);
   });

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

@@ -645,7 +645,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";
@@ -678,6 +678,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

@@ -408,10 +408,10 @@ console.log('\n=== complete-slice: handler with missing roadmap ===');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// complete-slice: step 13 specifies write tool for PROJECT.md (#2946)
+// complete-slice: PROJECT refresh uses DB-backed artifact tool.
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== complete-slice: step 13 specifies write tool for PROJECT.md (#2946) ===');
+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 +419,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);