gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.0aaa4fc17

package/src/resources/extensions/gsd/tests/pr-evidence-equivalence.test.ts

@@ -0,0 +1,102 @@
+// Project/App: GSD-2
+// File Purpose: Golden-fixture equivalence tests pinning PR-body output for buildPrEvidence and formatSwarmLanePRBody.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import { buildPrEvidence, type PrEvidenceInput } from "../pr-evidence.ts";
+import {
+  formatSwarmLanePRBody,
+  type SwarmLanePRData,
+} from "../../github-sync/templates.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = join(__dirname, "fixtures", "pr-body");
+
+const UPDATE = process.env.UPDATE_GOLDENS === "1";
+
+function compareGolden(name: string, actual: string): void {
+  const path = join(FIXTURES_DIR, name);
+  if (UPDATE) {
+    writeFileSync(path, actual, "utf8");
+    return;
+  }
+  const expected = readFileSync(path, "utf8");
+  assert.equal(actual, expected, `golden mismatch for ${name}`);
+}
+
+const SHIP_BASIC: PrEvidenceInput = {
+  milestoneId: "M001",
+  milestoneTitle: "Authentication",
+  changeType: "feat",
+  linkedIssue: "Closes #123",
+  summaries: ["### S01\nImplemented login flow."],
+  roadmapItems: ["- [x] **S01: Login**"],
+  metrics: ["**Units executed:** 3"],
+  testsRun: ["npm test", "npm run typecheck:extensions"],
+  why: "Users need to authenticate before accessing protected resources.",
+  how: "Added password hash check and session token issuance.",
+  rollbackNotes: ["Revert the merge commit."],
+};
+
+const SHIP_EMPTY_OPTIONALS: PrEvidenceInput = {
+  milestoneId: "M001",
+  milestoneTitle: "Authentication",
+  changeType: "feat",
+};
+
+const SWARM_WITH_BLOCKERS: SwarmLanePRData = {
+  lane: {
+    id: "writer",
+    branch: "lane/single-writer",
+    owner: "@owner",
+    latestCommit: "abc1234",
+    changedContracts: ["WriterToken"],
+    testEvidence: ["npm run typecheck:extensions"],
+    blockers: ["Awaiting state-lane writer-sequence merge", "Parity report incomplete"],
+  },
+  impactArea: "Single-writer UOK metadata.",
+  transitionRisks: ["Writer token lifecycle regression"],
+  rollbackPlan: ["Disable writer sequence enrichment"],
+  linkedIssue: 123,
+};
+
+const SWARM_NO_BLOCKERS: SwarmLanePRData = {
+  lane: {
+    id: "writer",
+    branch: "lane/single-writer",
+    owner: "@owner",
+    latestCommit: "abc1234",
+    changedContracts: ["WriterToken"],
+    testEvidence: ["npm run typecheck:extensions"],
+  },
+  impactArea: "Single-writer UOK metadata.",
+  transitionRisks: ["Writer token lifecycle regression"],
+  rollbackPlan: ["Disable writer sequence enrichment"],
+  linkedIssue: 123,
+};
+
+test("pr-evidence golden: commands-ship basic", () => {
+  compareGolden("commands-ship-basic.md", buildPrEvidence(SHIP_BASIC).body);
+});
+
+test("pr-evidence golden: commands-ship empty optionals", () => {
+  compareGolden("commands-ship-empty-optionals.md", buildPrEvidence(SHIP_EMPTY_OPTIONALS).body);
+});
+
+test("pr-evidence golden: swarm-lane with blockers", () => {
+  const body = formatSwarmLanePRBody(SWARM_WITH_BLOCKERS);
+  compareGolden("swarm-lane-with-blockers.md", body);
+  // Cross-check: top-level ## Blockers heading must appear (regression guard
+  // for the silent-drop fixed in this PR).
+  assert.ok(body.includes("\n## Blockers\n"), "swarm-lane body must emit a top-level ## Blockers heading");
+});
+
+test("pr-evidence golden: swarm-lane no blockers (no Blockers heading)", () => {
+  const body = formatSwarmLanePRBody(SWARM_NO_BLOCKERS);
+  compareGolden("swarm-lane-no-blockers.md", body);
+  assert.ok(!body.includes("## Blockers"), "swarm-lane body without blockers must not emit ## Blockers heading");
+});

package/src/resources/extensions/gsd/tests/pr-evidence-hardening.test.ts

@@ -0,0 +1,165 @@
+// Project/App: GSD-2
+// File Purpose: Hardening tests for buildPrEvidence — HTML-comment stripping, fake commit-trailer removal, and per-item length capping.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildPrEvidence, type PrEvidenceInput } from "../pr-evidence.ts";
+
+test("pr-evidence hardening: strips HTML comments from summaries", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    summaries: ["visible<!-- hidden secret -->tail"],
+  });
+  assert.ok(!evidence.body.includes("<!--"), "raw <!-- must not appear");
+  assert.ok(!evidence.body.includes("hidden secret"), "comment contents must be stripped");
+  assert.ok(evidence.body.includes("visibletail"), "non-comment text must remain");
+});
+
+test("pr-evidence hardening: removes Co-Authored-By trailer from why", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    why: "Real reason here.\nCo-Authored-By: Evil <e@evil.com>\nMore reason.",
+  });
+  assert.ok(!evidence.body.includes("Evil <e@evil.com>"));
+  assert.ok(!/Co-Authored-By:/i.test(evidence.body));
+  assert.ok(evidence.body.includes("Real reason here."));
+  assert.ok(evidence.body.includes("More reason."));
+});
+
+test("pr-evidence hardening: removes Signed-off-by trailer from how", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    how: "Step one.\nSigned-off-by: Forged <f@x.com>\nStep two.",
+  });
+  assert.ok(!evidence.body.includes("Forged <f@x.com>"));
+  assert.ok(!/Signed-off-by:/i.test(evidence.body));
+  assert.ok(evidence.body.includes("Step one."));
+  assert.ok(evidence.body.includes("Step two."));
+});
+
+test("pr-evidence hardening: trailer-name match is case-insensitive", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    why: "ok\nco-authored-by: lower <l@l.com>\nSIGNED-OFF-BY: upper <u@u.com>\nend",
+  });
+  assert.ok(!evidence.body.includes("lower <l@l.com>"));
+  assert.ok(!evidence.body.includes("upper <u@u.com>"));
+  assert.ok(evidence.body.includes("ok"));
+  assert.ok(evidence.body.includes("end"));
+});
+
+test("pr-evidence hardening: caps oversize summaries item with truncation suffix", () => {
+  const big = "A".repeat(5 * 1024); // 5 KB
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    summaries: [big],
+  });
+  // Find the truncated A-block in the body and assert it is bounded.
+  const lines = evidence.body.split("\n");
+  const longLine = lines.find((l) => l.startsWith("AAAA"));
+  assert.ok(longLine, "expected truncated A-line in body");
+  assert.ok(longLine!.endsWith(" … [truncated]"), "must end with truncation suffix");
+  assert.ok(
+    Buffer.byteLength(longLine!, "utf8") <= 2048,
+    `truncated item must be within 2 KB cap, got ${Buffer.byteLength(longLine!, "utf8")}`,
+  );
+});
+
+test("pr-evidence hardening: HTML comment split across summary items is preserved literally", () => {
+  // Documented behavior: each item is sanitized independently. A comment
+  // that begins in one item and closes in the next is NOT joined, so the
+  // open/close markers remain as literal text. This is intentional — joining
+  // items before sanitizing would let an attacker straddle items to inject
+  // an aligned comment that hides the second item from rendered view.
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    summaries: ["first item ends <!--", "--> second item begins"],
+  });
+  // The literal markers survive because each item was sanitized alone.
+  assert.ok(evidence.body.includes("<!--"), "open marker preserved as literal");
+  assert.ok(evidence.body.includes("-->"), "close marker preserved as literal");
+  assert.ok(evidence.body.includes("first item ends"));
+  assert.ok(evidence.body.includes("second item begins"));
+});
+
+test("pr-evidence hardening: clean input is byte-identical to pre-hardening output", () => {
+  // This test is the contract that protects the golden fixtures: the
+  // sanitizer must be a true no-op for well-formed input. If this fails,
+  // there is a bug in the sanitizer (not in the goldens).
+  const cleanInput: PrEvidenceInput = {
+    milestoneId: "M001",
+    milestoneTitle: "Authentication",
+    changeType: "feat",
+    linkedIssue: "Closes #123",
+    summaries: ["### S01\nImplemented login flow."],
+    blockers: ["Awaiting design review"],
+    roadmapItems: ["- [x] **S01: Login**"],
+    metrics: ["**Units executed:** 3"],
+    testsRun: ["npm test", "npm run typecheck:extensions"],
+    why: "Users need to authenticate before accessing protected resources.",
+    how: "Added password hash check and session token issuance.",
+    rollbackNotes: ["Revert the merge commit."],
+  };
+
+  const expected = [
+    "## TL;DR",
+    "",
+    "**What:** Ship milestone M001 - Authentication",
+    "**Why:** Users need to authenticate before accessing protected resources.",
+    "**How:** Added password hash check and session token issuance.",
+    "",
+    "## What",
+    "",
+    "### S01\nImplemented login flow.",
+    "",
+    "## Blockers",
+    "",
+    "- Awaiting design review",
+    "",
+    "## Why",
+    "",
+    "Users need to authenticate before accessing protected resources.",
+    "",
+    "## How",
+    "",
+    "Added password hash check and session token issuance.",
+    "",
+    "## Linked Issue",
+    "",
+    "Closes #123",
+    "",
+    "## Roadmap",
+    "",
+    "- [x] **S01: Login**",
+    "",
+    "## Metrics",
+    "",
+    "- **Units executed:** 3",
+    "",
+    "## Tests Run",
+    "",
+    "- npm test",
+    "- npm run typecheck:extensions",
+    "",
+    "## Change Type",
+    "",
+    "- [x] `feat` - New feature or capability",
+    "- [ ] `fix` - Bug fix",
+    "- [ ] `refactor` - Code restructuring",
+    "- [ ] `test` - Adding or updating tests",
+    "- [ ] `docs` - Documentation only",
+    "- [ ] `chore` - Build, CI, or tooling changes",
+    "",
+    "## Rollback And Compatibility",
+    "",
+    "- Revert the merge commit.",
+    "",
+    "## AI Assistance Disclosure",
+    "",
+    "This PR was prepared with AI assistance.",
+  ].join("\n");
+
+  const actual = buildPrEvidence(cleanInput).body;
+  assert.equal(actual, expected, "clean input must produce byte-identical output (sanitizer is no-op)");
+});

package/src/resources/extensions/gsd/tests/pr-evidence.test.ts

@@ -0,0 +1,79 @@
+// Project/App: GSD-2
+// File Purpose: Tests for the shared GSD pull request evidence generator.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildPrEvidence, type PrChangeType } from "../pr-evidence.ts";
+
+test("pr-evidence: generated body includes contribution-required sections", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    milestoneTitle: "Authentication",
+    linkedIssue: "Closes #123",
+    summaries: ["### S01\nImplemented login."],
+    roadmapItems: ["- [x] **S01: Login**"],
+    metrics: ["**Units executed:** 3"],
+    testsRun: ["npm test"],
+    rollbackNotes: ["Revert the merge commit."],
+  });
+
+  assert.equal(evidence.title, "feat: Authentication");
+  for (const section of [
+    "## TL;DR",
+    "## What",
+    "## Why",
+    "## How",
+    "## Linked Issue",
+    "## Tests Run",
+    "## Change Type",
+    "## Rollback And Compatibility",
+    "## AI Assistance Disclosure",
+  ]) {
+    assert.ok(evidence.body.includes(section), `missing section: ${section}`);
+  }
+  assert.ok(evidence.body.includes("Closes #123"));
+  assert.ok(evidence.body.includes("npm test"));
+  assert.ok(evidence.body.includes("This PR was prepared with AI assistance."));
+});
+
+test("pr-evidence: every change type selects exactly one checklist row", () => {
+  const changeTypes: PrChangeType[] = ["feat", "fix", "refactor", "test", "docs", "chore"];
+
+  for (const changeType of changeTypes) {
+    const evidence = buildPrEvidence({ milestoneId: "M001", changeType });
+    const checkedRows = evidence.body.split("\n").filter((line) => line.startsWith("- [x] `"));
+    assert.deepEqual(checkedRows, [
+      `- [x] \`${changeType}\` - ${{
+        feat: "New feature or capability",
+        fix: "Bug fix",
+        refactor: "Code restructuring",
+        test: "Adding or updating tests",
+        docs: "Documentation only",
+        chore: "Build, CI, or tooling changes",
+      }[changeType]}`,
+    ]);
+  }
+});
+
+test("pr-evidence: missing issue, tests, and rollback data are explicit", () => {
+  const evidence = buildPrEvidence({ milestoneId: "M001", aiAssisted: false });
+
+  assert.ok(evidence.body.includes("Not specified. Add an issue link"));
+  assert.ok(evidence.body.includes("Not specified. Add exact verification commands"));
+  assert.ok(evidence.body.includes("No behavior-changing rollback notes recorded."));
+  assert.ok(!evidence.body.includes("## AI Assistance Disclosure"));
+});
+
+test("pr-evidence: subject metadata supports non-milestone PRs", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    subjectId: "S01",
+    subjectKind: "slice",
+    milestoneTitle: "Auth Slice",
+  });
+
+  assert.equal(evidence.title, "feat: Auth Slice");
+  assert.ok(evidence.body.includes("Ship slice S01 - Auth Slice"));
+  assert.ok(evidence.body.includes("Slice work is complete and ready for review."));
+});

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

@@ -0,0 +1,51 @@
+// Project/App: GSD-2
+// File Purpose: Tests for canonical process recommendations by task size.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatRecommendedProcessPaths,
+  listRecommendedProcessPaths,
+  recommendProcessPath,
+  type ProcessTaskSize,
+} from "../process-task-path.ts";
+
+test("process task paths cover every Phase 7 task size with one command", () => {
+  const expected: ProcessTaskSize[] = [
+    "hotfix",
+    "bugfix",
+    "small-feature",
+    "large-feature",
+    "architecture-change",
+  ];
+
+  const paths = listRecommendedProcessPaths();
+  assert.deepEqual(paths.map((path) => path.taskSize), expected);
+
+  for (const taskSize of expected) {
+    const path = recommendProcessPath(taskSize);
+    assert.equal(path.taskSize, taskSize);
+    assert.ok(path.templateId.length > 0);
+    assert.match(path.command, /^\/gsd /);
+    assert.ok(path.phases.length > 0);
+    assert.ok(path.guidance.length > 0);
+  }
+});
+
+test("process task paths route large work to the DB-backed milestone flow", () => {
+  const largeFeature = recommendProcessPath("large-feature");
+  assert.equal(largeFeature.templateId, "full-project");
+  assert.match(largeFeature.command, /\/gsd discuss/);
+  assert.match(largeFeature.command, /\/gsd auto/);
+  assert.match(largeFeature.guidance, /DB-backed milestone flow/);
+});
+
+test("formatted process paths are stable for command help", () => {
+  const formatted = formatRecommendedProcessPaths();
+  assert.match(formatted, /hotfix\s+\/gsd start hotfix/);
+  assert.match(formatted, /bugfix\s+\/gsd start bugfix/);
+  assert.match(formatted, /small-feature\s+\/gsd start small-feature/);
+  assert.match(formatted, /large-feature\s+\/gsd discuss/);
+  assert.match(formatted, /architecture-change\s+\/gsd start refactor/);
+});

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

@@ -2,7 +2,7 @@
  * Regression test for #3696 — prompt step ordering and runtime fixes
  *
  * 1. complete-milestone.md: gsd_requirement_update (step 9) before
- *    gsd_complete_milestone (step 10)
+ *    gsd_complete_milestone, and completion remains the final durable write
  * 2. complete-slice.md: uses gsd_requirement_update
  * 3. register-extension.ts: _gsdEpipeGuard logs instead of re-throwing
  * 4. register-hooks.ts: session_before_compact only checks isAutoActive
@@ -50,6 +50,21 @@ describe('prompt step ordering (#3696)', () => {
     );
   });
 
+  test('project and learnings writes appear before gsd_complete_milestone', () => {
+    const projectMatch = completeMilestoneMd.match(/^\d+\.\s.*PROJECT\.md/m);
+    const learningsMatch = completeMilestoneMd.match(/^\d+\.\s.*Extract structured learnings/m);
+    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
+    assert.ok(projectMatch, 'PROJECT.md update should appear in a numbered step');
+    assert.ok(learningsMatch, 'learnings extraction should appear in a numbered step');
+    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
+
+    const projectIdx = completeMilestoneMd.indexOf(projectMatch![0]);
+    const learningsIdx = completeMilestoneMd.indexOf(learningsMatch![0]);
+    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
+    assert.ok(projectIdx < completeMilestoneIdx, 'PROJECT.md update must happen before gsd_complete_milestone');
+    assert.ok(learningsIdx < completeMilestoneIdx, 'learnings extraction must happen before gsd_complete_milestone');
+  });
+
   test('complete-slice.md uses gsd_requirement_update', () => {
     assert.match(completeSliceMd, /gsd_requirement_update/,
       'complete-slice.md should reference gsd_requirement_update');

package/src/resources/extensions/gsd/tests/queue-prompt-rendering.test.ts

@@ -0,0 +1,37 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the queue prompt renders compact discussion and write-gate guidance.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("queue prompt renders compact draft, verification, and persistence guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-queue-render-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("queue", {
+    preamble: "Queue preamble.",
+    existingMilestonesContext: "No existing milestones.",
+    commitInstruction: "Commit queued milestone artifacts.",
+    inlinedTemplates: "## Context Template\n\nUse standard GSD context.",
+  });
+
+  assert.match(prompt, /Draft Awareness/);
+  assert.match(prompt, /What do you want to add\?/);
+  assert.match(prompt, /Investigate between question rounds/);
+  assert.match(prompt, /Pre-Write Verification/);
+  assert.match(prompt, /depth_verification/);
+  assert.match(prompt, /gsd_milestone_generate_id/);
+  assert.match(prompt, /gsd_summary_save/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});

package/src/resources/extensions/gsd/tests/right-sized-workflow-prompts.test.ts

@@ -0,0 +1,192 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildCompleteMilestonePrompt, buildPlanMilestonePrompt } from "../auto-prompts.ts";
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: { ...process.env, GIT_AUTHOR_NAME: "Test User", GIT_AUTHOR_EMAIL: "test@example.com", GIT_COMMITTER_NAME: "Test User", GIT_COMMITTER_EMAIL: "test@example.com" },
+  }).trim();
+}
+
+function makeRepo(files: Record<string, string>): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-right-size-"));
+  git(base, ["init", "-b", "main"]);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# Context\n\nTest milestone.");
+  for (const [path, content] of Object.entries(files)) {
+    const abs = join(base, path);
+    mkdirSync(join(abs, ".."), { recursive: true });
+    writeFileSync(abs, content);
+  }
+  git(base, ["add", "."]);
+  git(base, ["commit", "-m", "init"]);
+  return base;
+}
+
+function writeCompleteMilestoneFiles(base: string, validation: string): void {
+  const dir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(dir, "slices", "S01"), { recursive: true });
+  writeFileSync(join(dir, "M001-ROADMAP.md"), "# M001\n\n## Slices\n- [x] **S01: One** `risk:low` `depends:[]`\n  > Done\n");
+  writeFileSync(join(dir, "M001-VALIDATION.md"), validation);
+  writeFileSync(join(dir, "slices", "S01", "S01-SUMMARY.md"), "# S01 Summary\n\n**Verification:** passed\n");
+}
+
+function validationMetadata(): string {
+  return [
+    "validation_metadata:",
+    "  covered_artifacts:",
+    "    - `.gsd/milestones/M001/M001-VALIDATION.md`",
+    "    - `.gsd/milestones/M001/M001-ROADMAP.md`",
+    "    - `.gsd/milestones/M001/slices/S01/S01-SUMMARY.md`",
+  ].join("\n");
+}
+
+test("plan-milestone prompt includes tiny untyped project classification and one-slice guidance", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* untyped-existing/);
+    assert.match(prompt, /\*\*Content files:\*\* 1/);
+    assert.match(prompt, /`index\.html`/);
+    assert.match(prompt, /Prefer exactly one slice/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("plan-milestone prompt includes small untyped project 1-2 slice guidance", async () => {
+  const base = makeRepo({
+    "index.html": "html",
+    "README.md": "readme",
+    "styles.css": "body {}",
+  });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Polish static files", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* untyped-existing/);
+    assert.match(prompt, /\*\*Content files:\*\* 3/);
+    assert.match(prompt, /Prefer 1-2 slices/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("plan-milestone prompt keeps normal guidance for typed projects", async () => {
+  const base = makeRepo({
+    "package.json": "{\"scripts\":{\"test\":\"node --test\"}}\n",
+    "src/index.js": "console.log('ok');\n",
+  });
+  try {
+    const prompt = await buildPlanMilestonePrompt("M001", "Update app", base, "minimal");
+    assert.match(prompt, /\*\*Kind:\*\* typed-existing/);
+    assert.match(prompt, /Use normal ecosystem-aware planning guidance/);
+    assert.doesNotMatch(prompt, /Prefer exactly one slice/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("workflow docs no longer contain blanket 4-10 slice guidance", () => {
+  const docs = readFileSync(join(process.cwd(), "src", "resources", "GSD-WORKFLOW.md"), "utf-8");
+  assert.doesNotMatch(docs, /4-10 slices/);
+  assert.match(docs, /1-10 slices/);
+  assert.match(docs, /single-file/);
+});
+
+test("prompt templates carry right-sized planning and closeout mode guidance", () => {
+  const planTemplate = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "prompts", "plan-milestone.md"), "utf-8");
+  const completeTemplate = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "prompts", "complete-milestone.md"), "utf-8");
+
+  assert.match(planTemplate, /Use 1-10 slices, sized to the work/);
+  assert.match(planTemplate, /tiny\/single-file\/static work should usually be one slice/);
+  assert.match(planTemplate, /untyped-existing/);
+  assert.match(completeTemplate, /Closeout Review Mode/);
+  assert.match(completeTemplate, /passing validation artifact is present/);
+  assert.doesNotMatch(completeTemplate, /^### Delegate Review Work/m);
+});
+
+test("complete-milestone prompt trusts passing validation artifact", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\n${validationMetadata()}\n\nAll checks passed.`);
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Passing Validation Artifact/);
+    assert.match(prompt, /Treat it as authoritative/);
+    assert.match(prompt, /Do not delegate fresh reviewer\/security\/tester audits/);
+    assert.match(prompt, /All checks passed/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt trusts centralized markdown body pass verdict", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, `# Validation\n\n**Verdict:** PASS\n\n${validationMetadata()}\n\nAll checks passed.`);
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Passing Validation Artifact/);
+    assert.match(prompt, /Treat it as authoritative/);
+    assert.match(prompt, /Do not delegate fresh reviewer\/security\/tester audits/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt does not trust stale pass validation without metadata", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nAll checks passed.");
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /missing freshness metadata/);
+    assert.doesNotMatch(prompt, /Passing Validation Artifact/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt does not trust pass validation missing current summary coverage", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, [
+      "---",
+      "verdict: pass",
+      "remediation_round: 0",
+      "---",
+      "",
+      "# Validation",
+      "validation_metadata:",
+      "  covered_artifacts:",
+      "    - `.gsd/milestones/M001/M001-VALIDATION.md`",
+      "    - `.gsd/milestones/M001/M001-ROADMAP.md`",
+      "",
+      "All checks passed.",
+    ].join("\n"));
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /does not cover current milestone artifacts/);
+    assert.doesNotMatch(prompt, /Passing Validation Artifact/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("complete-milestone prompt keeps deeper review path without passing validation", async () => {
+  const base = makeRepo({ "index.html": "<!doctype html>\n<title>Test</title>\n" });
+  try {
+    writeCompleteMilestoneFiles(base, "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nFix gaps.");
+    const prompt = await buildCompleteMilestonePrompt("M001", "Polish static page", base, "minimal");
+    assert.match(prompt, /Validation Requires Attention/);
+    assert.match(prompt, /verdict `needs-attention`/);
+    assert.match(prompt, /Use `subagent` for review work needing fresh context/i);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});