@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

package/src/resources/extensions/gsd/tests/integration/merge-strategy-regular.test.ts

@@ -0,0 +1,157 @@
+// Integration regression for #549: merge_strategy: merge is not respected.
+//
+// mergeMilestoneToMain always called nativeMergeSquash regardless of the
+// git.merge_strategy preference. When a user set `merge_strategy: merge`
+// (to respect a global `merge.ff = false`), the squash path still ran.
+//
+// Fix (#549): an `effectiveStrategy` variable selects nativeMergeRegular
+// (--no-ff --no-commit) when merge_strategy === "merge", leaving MERGE_HEAD
+// so nativeCommit produces a real merge commit with two parents.
+//
+// These tests verify:
+//   1. merge_strategy: merge → merge commit topology (two parents on main).
+//   2. No merge_strategy set → squash commit topology (one parent on main).
+//   3. Error messages reference the correct strategy label ("Merge" vs
+//      "Squash merge") so users are not misled when a conflict or dirty-tree
+//      error occurs under the merge strategy.
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { createAutoWorktree, mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { closeDatabase } from "../../gsd-db.ts";
+import { getSliceBranchName } from "../../worktree.ts";
+
+function run(cmd: string, cwd: string): string {
+  // Safe: all inputs are hardcoded test strings, not user input
+  return execSync(cmd, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "merge-strategy-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  run("git config core.autocrlf false", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function makeRoadmap(milestoneId: string, title: string): string {
+  return `# ${milestoneId}: ${title}\n\n## Slices\n- [x] **S01: Feature**\n`;
+}
+
+function addSliceToMilestone(
+  repo: string,
+  wtPath: string,
+  milestoneId: string,
+  sliceId: string,
+  sliceTitle: string,
+  fileName: string,
+): void {
+  const normalizedPath = wtPath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  const worktreeName =
+    idx !== -1 ? normalizedPath.slice(idx + marker.length).split("/")[0] : null;
+
+  const sliceBranch = getSliceBranchName(milestoneId, sliceId, worktreeName);
+
+  run(`git checkout -b ${sliceBranch}`, wtPath);
+  writeFileSync(join(wtPath, fileName), `export const feature = true;\n`);
+  run("git add .", wtPath);
+  run(`git commit -m "feat: ${sliceTitle}"`, wtPath);
+  run(`git checkout milestone/${milestoneId}`, wtPath);
+  run(
+    `git merge --no-ff ${sliceBranch} -m "feat(${milestoneId}/${sliceId}): ${sliceTitle}"`,
+    wtPath,
+  );
+  run(`git branch -d ${sliceBranch}`, wtPath);
+}
+
+/** Number of parents of the most recent commit on a branch. */
+function parentCount(repo: string, branch: string): number {
+  const parents = run(`git log -1 --format=%P ${branch}`, repo);
+  return parents.trim() === "" ? 0 : parents.trim().split(/\s+/).length;
+}
+
+describe("mergeMilestoneToMain merge_strategy dispatch (#549)", { timeout: 300_000 }, () => {
+  const savedCwd = process.cwd();
+  const tempDirs: string[] = [];
+
+  function freshRepo(): string {
+    const d = createTempRepo();
+    tempDirs.push(d);
+    return d;
+  }
+
+  afterEach(() => {
+    process.chdir(savedCwd);
+    closeDatabase();
+    for (const d of tempDirs) {
+      if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  test("#549: merge_strategy: merge produces a true merge commit with two parents", () => {
+    const repo = freshRepo();
+
+    // Write project preferences with merge_strategy: merge
+    writeFileSync(
+      join(repo, ".gsd", "PREFERENCES.md"),
+      "---\nversion: 1\ngit:\n  merge_strategy: merge\n---\n",
+    );
+
+    const wtPath = createAutoWorktree(repo, "M549");
+    addSliceToMilestone(repo, wtPath, "M549", "S01", "Feature A", "feature-a.ts");
+
+    const roadmap = makeRoadmap("M549", "Merge strategy milestone");
+    mergeMilestoneToMain(repo, "M549", roadmap);
+
+    assert.equal(
+      parentCount(repo, "main"),
+      2,
+      "merge_strategy: merge must produce a true merge commit with 2 parents on main",
+    );
+    assert.ok(existsSync(join(repo, "feature-a.ts")), "feature-a.ts present on main");
+  });
+
+  test("default (no merge_strategy): squash commit has one parent on main", () => {
+    const repo = freshRepo();
+    // No PREFERENCES.md — default squash path
+
+    const wtPath = createAutoWorktree(repo, "M550");
+    addSliceToMilestone(repo, wtPath, "M550", "S01", "Feature B", "feature-b.ts");
+
+    const roadmap = makeRoadmap("M550", "Squash strategy milestone");
+    mergeMilestoneToMain(repo, "M550", roadmap);
+
+    assert.equal(
+      parentCount(repo, "main"),
+      1,
+      "default (squash) must produce a single-parent commit on main",
+    );
+    assert.ok(existsSync(join(repo, "feature-b.ts")), "feature-b.ts present on main");
+  });
+});

package/src/resources/extensions/gsd/tests/markdown-renderer-parse-cache.test.ts

@@ -0,0 +1,75 @@
+// Project/App: gsd-pi
+// File Purpose: Performance-contract test for the detectStaleRenders file-identity
+// parse cache (#442 Phase 1.5). Asserts the observable contract: an unchanged
+// projection is NOT re-parsed on the next dispatch (cache hit), while a changed
+// projection IS re-parsed (cache miss on path+mtime+size). Modeled on the
+// prepared-statement caching contract test in db-adapter.test.ts — it asserts
+// external behavior (parse happened / did not), never internal wiring.
+
+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 { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
+import { clearParseCache } from "../files.ts";
+import { clearPathCache } from "../paths.ts";
+import { invalidateStateCache } from "../state.ts";
+import { detectStaleRenders } from "../markdown-renderer.ts";
+import { enableDebug, disableDebug, getDebugCounters } from "../debug-logger.ts";
+
+function roadmapMd(slices: Array<{ id: string; title: string; done: boolean }>): string {
+  const lines = ["# M001 Roadmap", "", "**Vision:** cache contract", "", "## Slices", ""];
+  for (const s of slices) lines.push(`- ${s.done ? "[x]" : "[ ]"} **${s.id}: ${s.title}** \`risk:medium\` \`depends:[]\``);
+  lines.push("");
+  return lines.join("\n");
+}
+
+test("#442: detectStaleRenders re-parses ROADMAP only when it changes on disk", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parse-cache-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    disableDebug();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Cache", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", risk: "medium", depends: [], sequence: 1 });
+
+  // Start from a cold cache so counts are attributable to this test.
+  clearParseCache();
+  clearPathCache();
+  invalidateStateCache();
+
+  writeFileSync(roadmapPath, roadmapMd([{ id: "S01", title: "Slice", done: false }]));
+
+  enableDebug(base); // resets counters
+
+  // First dispatch: cold cache → the roadmap is read + parsed.
+  detectStaleRenders(base);
+  const afterCold = getDebugCounters().parseRoadmapCalls;
+  assert.ok(afterCold > 0, "cold dispatch must parse the roadmap");
+
+  // Second dispatch, file unchanged: cache hit → NO new parse.
+  detectStaleRenders(base);
+  const afterWarm = getDebugCounters().parseRoadmapCalls;
+  assert.equal(afterWarm, afterCold, "unchanged projection must not be re-parsed");
+
+  // Change the file (different content AND size) WITHOUT clearing caches:
+  // the path+mtime+size identity changes, forcing a re-parse.
+  writeFileSync(
+    roadmapPath,
+    roadmapMd([
+      { id: "S01", title: "Slice", done: true },
+      { id: "S02", title: "Added Slice", done: false },
+    ]),
+  );
+  detectStaleRenders(base);
+  const afterChange = getDebugCounters().parseRoadmapCalls;
+  assert.ok(afterChange > afterWarm, "a changed projection must be re-parsed");
+});

package/src/resources/extensions/gsd/tests/mcp-tool-name.test.ts

@@ -0,0 +1,34 @@
+// Project/App: gsd-pi
+// File Purpose: Regression coverage for shared MCP tool-name parsing helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  mcpToolMatchesBaseName,
+  parseMcpToolName,
+  stripMcpToolPrefix,
+  toMcpToolName,
+  toMcpWildcardToolName,
+} from "../mcp-tool-name.ts";
+
+test("parseMcpToolName parses exact and wildcard MCP tool names", () => {
+  assert.deepEqual(parseMcpToolName("mcp__gsd-workflow__ask_user_questions"), {
+    serverName: "gsd-workflow",
+    toolName: "ask_user_questions",
+  });
+  assert.deepEqual(parseMcpToolName("mcp__gsd-browser__*"), {
+    serverName: "gsd-browser",
+    toolName: "*",
+  });
+  assert.equal(parseMcpToolName("browser_navigate"), null);
+});
+
+test("MCP tool-name helpers strip, match, and format names consistently", () => {
+  assert.equal(stripMcpToolPrefix("mcp__custom-workflow__gsd_exec"), "gsd_exec");
+  assert.equal(stripMcpToolPrefix("read"), "read");
+  assert.equal(mcpToolMatchesBaseName("mcp__custom-workflow__gsd_exec", "gsd_exec"), true);
+  assert.equal(mcpToolMatchesBaseName("mcp__custom-workflow__gsd_exec", "gsd_summary_save"), false);
+  assert.equal(toMcpToolName("custom-workflow", "gsd_exec"), "mcp__custom-workflow__gsd_exec");
+  assert.equal(toMcpWildcardToolName("custom-workflow"), "mcp__custom-workflow__*");
+});

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -287,3 +287,61 @@ test("migration auto-check refreshes a stale open DB handle before comparing", a
     cleanup(base);
   }
 });
+
+test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra rows", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Legacy Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "Legacy slice demo",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Legacy Task",
+      status: "pending",
+    });
+    insertSlice({
+      id: "S02",
+      milestoneId: "M001",
+      title: "Added in DB",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "d",
+      sequence: 2,
+    });
+    insertTask({
+      id: "T02",
+      sliceId: "S02",
+      milestoneId: "M001",
+      title: "Added task",
+      status: "pending",
+    });
+
+    const before = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(before.recoveryCommand, "/gsd rebuild markdown");
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected markdown projections to render");
+
+    const after = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(after.action, "none");
+    assert.equal(after.reason, "in-sync");
+    assert.deepEqual(after.markdown, { milestones: 1, slices: 2, tasks: 2 });
+    assert.deepEqual(after.beforeDb, { milestones: 1, slices: 2, tasks: 2 });
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -0,0 +1,99 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for the shared milestone closeout proof surface.
+
+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 {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.js";
+import { proveMilestoneCloseout } from "../milestone-closeout-proof.js";
+
+const tmpDirs: string[] = [];
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-closeout-proof-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try { closeDatabase(); } catch { /* noop */ }
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function insertValidationPass(): void {
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+}
+
+function writeSummary(base: string, status = "complete"): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+    `---\nstatus: ${status}\n---\n\n# Summary\n`,
+    "utf-8",
+  );
+}
+
+test.after(() => {
+  try { closeDatabase(); } catch { /* noop */ }
+  for (const dir of tmpDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("proveMilestoneCloseout accepts closed DB state plus summary artifact", () => {
+  const base = makeBase();
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertValidationPass();
+  writeSummary(base);
+
+  const result = proveMilestoneCloseout("M001", {
+    summaryArtifactBasePath: base,
+  });
+
+  assert.deepEqual(result, { ok: true });
+});
+
+test("proveMilestoneCloseout can prove readiness before DB milestone is closed", () => {
+  const base = makeBase();
+  insertMilestone({ id: "M001", title: "Ready", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertValidationPass();
+  writeSummary(base);
+
+  const result = proveMilestoneCloseout("M001", {
+    allowOpenMilestone: true,
+    summaryArtifactBasePath: base,
+  });
+
+  assert.deepEqual(result, { ok: true });
+});
+
+test("proveMilestoneCloseout rejects explicit failure summaries", () => {
+  const base = makeBase();
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertValidationPass();
+  writeSummary(base, "failed");
+
+  const result = proveMilestoneCloseout("M001", {
+    summaryArtifactBasePath: base,
+  });
+
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.equal(result.reason, "summary-artifact-failed");
+  }
+});

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

@@ -55,6 +55,31 @@ test("isMilestoneCloseoutSettled requires DB closed and summary artifact", async
   assert.equal(settled, true);
 });
 
+test("isMilestoneCloseoutSettled accepts summary artifacts in a live milestone worktree", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-milestone-closeout-worktree-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+
+  const worktreeRoot = join(base, ".gsd", "worktrees", "M001");
+  const milestoneDir = join(worktreeRoot, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(worktreeRoot, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M001")}\n`);
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\n");
+
+  const settled = await isMilestoneCloseoutSettled("M001", base);
+  assert.equal(settled, true);
+});
+
 test("isMilestoneCloseoutSettled returns false when summary artifact is missing", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-milestone-closeout-missing-"));
   tmpDirs.push(base);

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

@@ -0,0 +1,46 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for the milestone merge transaction wrapper.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  createMilestoneMergeTransaction,
+  runMilestoneMergeTransaction,
+} from "../milestone-merge-transaction.js";
+
+test("runMilestoneMergeTransaction delegates to the supplied merge runner", () => {
+  const calls: unknown[][] = [];
+  const result = runMilestoneMergeTransaction(
+    {
+      mergeMilestoneToMain: (basePath, milestoneId, roadmapContent) => {
+        calls.push([basePath, milestoneId, roadmapContent]);
+        return { pushed: true, codeFilesChanged: true, commitMessage: "merge M001" };
+      },
+    },
+    {
+      basePath: "/repo",
+      milestoneId: "M001",
+      roadmapContent: "# M001",
+    },
+  );
+
+  assert.deepEqual(calls, [["/repo", "M001", "# M001"]]);
+  assert.deepEqual(result, {
+    pushed: true,
+    codeFilesChanged: true,
+    commitMessage: "merge M001",
+  });
+});
+
+test("createMilestoneMergeTransaction returns a lifecycle-compatible runner", () => {
+  const runner = createMilestoneMergeTransaction(() => ({
+    pushed: false,
+    codeFilesChanged: false,
+  }));
+
+  assert.deepEqual(runner("/repo", "M002", "# M002"), {
+    pushed: false,
+    codeFilesChanged: false,
+  });
+});

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

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyMilestoneReadiness,
+  describeMilestoneReadinessPhase,
+  formatAcceptedDiscussHandoffMessage,
+  readinessNeedsDiscussion,
+} from "../milestone-readiness.ts";
+
+test("classifyMilestoneReadiness distinguishes queued shells from draft discussion work", () => {
+  const shell = classifyMilestoneReadiness({
+    status: "queued",
+    hasDraftContext: true,
+    sliceCount: 0,
+  });
+
+  assert.equal(shell.kind, "queued-shell");
+  assert.equal(readinessNeedsDiscussion(shell), true);
+});
+
+test("classifyMilestoneReadiness marks context-only milestones as planning pending", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "queued",
+    hasContext: true,
+    sliceCount: 0,
+  });
+
+  assert.equal(readiness.kind, "planning-pending");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 context captured. Continuing the planning pipeline.");
+});
+
+test("classifyMilestoneReadiness marks persisted slices as executable plan", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "active",
+    hasContext: true,
+    sliceCount: 1,
+  });
+
+  assert.equal(readiness.kind, "executable-plan");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 ready.");
+});
+
+test("formatAcceptedDiscussHandoffMessage preserves ready copy for any executable plan", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "complete",
+    hasContext: true,
+    sliceCount: 1,
+  });
+
+  assert.equal(readiness.kind, "terminal");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 ready.");
+});
+
+test("describeMilestoneReadinessPhase keeps dashboard phase copy centralized", () => {
+  assert.deepEqual(describeMilestoneReadinessPhase("needs-discussion"), {
+    label: "Discuss milestone draft",
+    description: "Milestone has a draft context — needs discussion before planning.",
+  });
+  assert.deepEqual(describeMilestoneReadinessPhase("pre-planning"), {
+    label: "Research & plan milestone",
+    description: "Scout the landscape and create the roadmap.",
+  });
+  assert.equal(describeMilestoneReadinessPhase("executing"), null);
+});

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

@@ -0,0 +1,41 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for forwarded milestone validation evidence helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyBrowserEvidenceGate,
+  hasRuntimeExecutableUatEvidenceText,
+} from "../milestone-validation-evidence.js";
+
+test("hasRuntimeExecutableUatEvidenceText requires runtime-executable PASS evidence", () => {
+  const evidence = [
+    "---",
+    "uatType: runtime-executable",
+    "verdict: PASS",
+    "---",
+    "| Check | Mode | Result | Evidence |",
+    "| DOM | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom.json |",
+  ].join("\n");
+
+  assert.equal(hasRuntimeExecutableUatEvidenceText(evidence), true);
+  assert.equal(hasRuntimeExecutableUatEvidenceText(evidence.replace("runtime | PASS", "manual | PASS")), false);
+});
+
+test("applyBrowserEvidenceGate records downgrade rationale", () => {
+  const params = applyBrowserEvidenceGate({
+    milestoneId: "M001",
+    verdict: "pass",
+    remediationRound: 0,
+    successCriteriaChecklist: "",
+    sliceDeliveryAudit: "",
+    crossSliceIntegration: "",
+    requirementCoverage: "",
+    verdictRationale: "Initial rationale.",
+  });
+
+  assert.equal(params.verdict, "needs-attention");
+  assert.match(params.verdictRationale, /Initial rationale/);
+  assert.match(params.verdictRationale, /Browser evidence gate/);
+});

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

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveMilestoneValidationVerdict } from "../milestone-validation-verdict.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+function setup(base: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  process.chdir(base);
+  _clearGsdRootCache();
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  invalidateAllCaches();
+}
+
+test("resolveMilestoneValidationVerdict prefers DB pass over stale worktree needs-attention", async () => {
+  const base = join(tmpdir(), `validation-verdict-${Date.now()}`);
+  mkdirSync(base, { recursive: true });
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), "gitdir: ../.git/worktrees/M001\n", "utf-8");
+  writeFileSync(
+    join(worktree, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+    "---\nverdict: needs-attention\n---\n\n# Validation\nStale worktree copy.\n",
+  );
+
+  try {
+    setup(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertAssessment({
+      path: join(worktree, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      milestoneId: "M001",
+      sliceId: null,
+      taskId: null,
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: pass\n---\n\n# Validation\nManual override.\n",
+    });
+
+    const verdict = await resolveMilestoneValidationVerdict(base, "M001");
+    assert.equal(verdict, "pass");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});