gsd-pi 2.49.0-dev.de3d9f6 → 2.50.0-dev.9476db8

package/src/resources/extensions/gsd/tests/quality-gates.test.ts

@@ -0,0 +1,347 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { extractSection } from "../files.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesDir = join(__dirname, "..", "templates");
+const promptsDir = join(__dirname, "..", "prompts");
+
+const { assertTrue, report } = createTestContext();
+
+function loadTemplate(name: string): string {
+  return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
+}
+
+function loadPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 1: Templates contain quality gate headings
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 1: Templates contain quality gate headings ===");
+{
+  const plan = loadTemplate("plan");
+  assertTrue(plan.includes("## Threat Surface"), "plan.md contains ## Threat Surface");
+  assertTrue(plan.includes("## Requirement Impact"), "plan.md contains ## Requirement Impact");
+
+  const taskPlan = loadTemplate("task-plan");
+  assertTrue(taskPlan.includes("## Failure Modes"), "task-plan.md contains ## Failure Modes");
+  assertTrue(taskPlan.includes("## Load Profile"), "task-plan.md contains ## Load Profile");
+  assertTrue(taskPlan.includes("## Negative Tests"), "task-plan.md contains ## Negative Tests");
+
+  const sliceSummary = loadTemplate("slice-summary");
+  assertTrue(sliceSummary.includes("## Operational Readiness"), "slice-summary.md contains ## Operational Readiness");
+
+  const roadmap = loadTemplate("roadmap");
+  assertTrue(roadmap.includes("## Horizontal Checklist"), "roadmap.md contains ## Horizontal Checklist");
+
+  const milestoneSummary = loadTemplate("milestone-summary");
+  assertTrue(milestoneSummary.includes("## Decision Re-evaluation"), "milestone-summary.md contains ## Decision Re-evaluation");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 2: Prompts reference quality gates
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 2: Prompts reference quality gates ===");
+{
+  const planSlice = loadPrompt("plan-slice");
+  assertTrue(planSlice.includes("Threat Surface"), "plan-slice.md mentions Threat Surface");
+  assertTrue(planSlice.includes("Requirement Impact"), "plan-slice.md mentions Requirement Impact");
+  assertTrue(planSlice.toLowerCase().includes("quality gate"), "plan-slice.md mentions quality gate");
+
+  const guidedPlanSlice = loadPrompt("guided-plan-slice");
+  assertTrue(
+    guidedPlanSlice.includes("Threat Surface") || guidedPlanSlice.includes("Q3"),
+    "guided-plan-slice.md mentions Threat Surface or Q3"
+  );
+
+  const executeTask = loadPrompt("execute-task");
+  assertTrue(executeTask.includes("Failure Modes"), "execute-task.md mentions Failure Modes");
+  assertTrue(executeTask.includes("Load Profile"), "execute-task.md mentions Load Profile");
+  assertTrue(executeTask.includes("Negative Tests"), "execute-task.md mentions Negative Tests");
+
+  const guidedExecuteTask = loadPrompt("guided-execute-task");
+  assertTrue(
+    guidedExecuteTask.includes("Failure Modes") || guidedExecuteTask.includes("Q5"),
+    "guided-execute-task.md mentions Failure Modes or Q5"
+  );
+
+  const completeSlice = loadPrompt("complete-slice");
+  assertTrue(completeSlice.includes("Operational Readiness"), "complete-slice.md mentions Operational Readiness");
+
+  const guidedCompleteSlice = loadPrompt("guided-complete-slice");
+  assertTrue(
+    guidedCompleteSlice.includes("Operational Readiness") || guidedCompleteSlice.includes("Q8"),
+    "guided-complete-slice.md mentions Operational Readiness or Q8"
+  );
+
+  const completeMilestone = loadPrompt("complete-milestone");
+  assertTrue(completeMilestone.includes("Horizontal Checklist"), "complete-milestone.md mentions Horizontal Checklist");
+  assertTrue(completeMilestone.includes("Decision Re-evaluation"), "complete-milestone.md mentions Decision Re-evaluation");
+
+  const planMilestone = loadPrompt("plan-milestone");
+  assertTrue(planMilestone.toLowerCase().includes("horizontal checklist"), "plan-milestone.md mentions horizontal checklist");
+
+  const guidedPlanMilestone = loadPrompt("guided-plan-milestone");
+  assertTrue(guidedPlanMilestone.includes("Horizontal Checklist"), "guided-plan-milestone.md mentions Horizontal Checklist");
+
+  const reassess = loadPrompt("reassess-roadmap");
+  assertTrue(reassess.includes("Threat Surface"), "reassess-roadmap.md mentions Threat Surface");
+  assertTrue(reassess.includes("Operational Readiness"), "reassess-roadmap.md mentions Operational Readiness");
+  assertTrue(reassess.includes("Horizontal Checklist"), "reassess-roadmap.md mentions Horizontal Checklist");
+
+  const replan = loadPrompt("replan-slice");
+  assertTrue(replan.includes("Threat Surface"), "replan-slice.md mentions Threat Surface");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 3: Parser backward compatibility — extractSection handles new headings
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 3: extractSection backward compatibility ===");
+{
+  // Old-style slice plan (no quality gate sections)
+  const oldPlan = `# S01: Auth Flow
+
+**Goal:** Build login
+**Demo:** User can log in
+
+## Must-Haves
+
+- Login form works
+- Session persists
+
+## Proof Level
+
+- This slice proves: integration
+
+## Tasks
+
+- [ ] **T01: Build login** \`est:1h\`
+`;
+
+  // New-style slice plan (with quality gate sections)
+  const newPlan = `# S01: Auth Flow
+
+**Goal:** Build login
+**Demo:** User can log in
+
+## Must-Haves
+
+- Login form works
+- Session persists
+
+## Threat Surface
+
+- **Abuse**: Credential stuffing, brute force login attempts
+- **Data exposure**: Session tokens in cookies, password in request body
+- **Input trust**: Username/password from form input reaching DB query
+
+## Requirement Impact
+
+- **Requirements touched**: R001, R003
+- **Re-verify**: Login flow, session management
+- **Decisions revisited**: D002
+
+## Proof Level
+
+- This slice proves: integration
+
+## Tasks
+
+- [ ] **T01: Build login** \`est:1h\`
+`;
+
+  // Old plan: quality gate sections return null (not found)
+  assertTrue(
+    extractSection(oldPlan, "Threat Surface") === null,
+    "extractSection returns null for Threat Surface on old plan"
+  );
+  assertTrue(
+    extractSection(oldPlan, "Requirement Impact") === null,
+    "extractSection returns null for Requirement Impact on old plan"
+  );
+
+  // Old plan: core sections still parse correctly
+  const oldMustHaves = extractSection(oldPlan, "Must-Haves");
+  assertTrue(
+    oldMustHaves !== null && oldMustHaves.includes("Login form works"),
+    "extractSection still parses Must-Haves on old plan"
+  );
+
+  // New plan: quality gate sections are extracted
+  const threatSurface = extractSection(newPlan, "Threat Surface");
+  assertTrue(
+    threatSurface !== null && threatSurface.includes("Credential stuffing"),
+    "extractSection extracts Threat Surface content from new plan"
+  );
+
+  const reqImpact = extractSection(newPlan, "Requirement Impact");
+  assertTrue(
+    reqImpact !== null && reqImpact.includes("R001"),
+    "extractSection extracts Requirement Impact content from new plan"
+  );
+
+  // New plan: core sections still parse correctly
+  const newMustHaves = extractSection(newPlan, "Must-Haves");
+  assertTrue(
+    newMustHaves !== null && newMustHaves.includes("Login form works"),
+    "extractSection still parses Must-Haves on new plan"
+  );
+
+  // Task plan: Failure Modes
+  const oldTaskPlan = `# T01: Build Login
+
+## Description
+
+Build the login endpoint.
+
+## Steps
+
+1. Create route
+`;
+
+  const newTaskPlan = `# T01: Build Login
+
+## Description
+
+Build the login endpoint.
+
+## Failure Modes
+
+| Dependency | On error | On timeout | On malformed response |
+|------------|----------|-----------|----------------------|
+| Auth DB | Return 500 | 3s timeout, retry once | Reject, log warning |
+
+## Steps
+
+1. Create route
+`;
+
+  assertTrue(
+    extractSection(oldTaskPlan, "Failure Modes") === null,
+    "extractSection returns null for Failure Modes on old task plan"
+  );
+
+  const failureModes = extractSection(newTaskPlan, "Failure Modes");
+  assertTrue(
+    failureModes !== null && failureModes.includes("Auth DB"),
+    "extractSection extracts Failure Modes content from new task plan"
+  );
+
+  // Slice summary: Operational Readiness
+  const oldSummary = `# S01: Auth Flow
+
+**Built login with session management**
+
+## Verification
+
+All tests pass.
+
+## Deviations
+
+None.
+`;
+
+  const newSummary = `# S01: Auth Flow
+
+**Built login with session management**
+
+## Verification
+
+All tests pass.
+
+## Operational Readiness
+
+- **Health signal**: /health endpoint returns 200 with session count
+- **Failure signal**: Auth error rate > 5% triggers alert
+- **Recovery**: Stateless — restart clears nothing
+- **Monitoring gaps**: None
+
+## Deviations
+
+None.
+`;
+
+  assertTrue(
+    extractSection(oldSummary, "Operational Readiness") === null,
+    "extractSection returns null for Operational Readiness on old summary"
+  );
+
+  const opReadiness = extractSection(newSummary, "Operational Readiness");
+  assertTrue(
+    opReadiness !== null && opReadiness.includes("/health endpoint"),
+    "extractSection extracts Operational Readiness content from new summary"
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 4: Template section ordering is correct
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 4: Template section ordering ===");
+{
+  const plan = loadTemplate("plan");
+  const mustHavesIdx = plan.indexOf("## Must-Haves");
+  const threatIdx = plan.indexOf("## Threat Surface");
+  const proofIdx = plan.indexOf("## Proof Level");
+  assertTrue(
+    mustHavesIdx < threatIdx && threatIdx < proofIdx,
+    "plan.md: Threat Surface is between Must-Haves and Proof Level"
+  );
+
+  const reqImpactIdx = plan.indexOf("## Requirement Impact");
+  assertTrue(
+    threatIdx < reqImpactIdx && reqImpactIdx < proofIdx,
+    "plan.md: Requirement Impact is between Threat Surface and Proof Level"
+  );
+
+  const taskPlan = loadTemplate("task-plan");
+  const descIdx = taskPlan.indexOf("## Description");
+  const failIdx = taskPlan.indexOf("## Failure Modes");
+  const stepsIdx = taskPlan.indexOf("## Steps");
+  assertTrue(
+    descIdx < failIdx && failIdx < stepsIdx,
+    "task-plan.md: Failure Modes is between Description and Steps"
+  );
+
+  const loadIdx = taskPlan.indexOf("## Load Profile");
+  const negIdx = taskPlan.indexOf("## Negative Tests");
+  assertTrue(
+    failIdx < loadIdx && loadIdx < negIdx && negIdx < stepsIdx,
+    "task-plan.md: Failure Modes < Load Profile < Negative Tests < Steps"
+  );
+
+  const sliceSummary = loadTemplate("slice-summary");
+  const reqInvalidIdx = sliceSummary.indexOf("## Requirements Invalidated");
+  const opIdx = sliceSummary.indexOf("## Operational Readiness");
+  const devIdx = sliceSummary.indexOf("## Deviations");
+  assertTrue(
+    reqInvalidIdx < opIdx && opIdx < devIdx,
+    "slice-summary.md: Operational Readiness is between Requirements Invalidated and Deviations"
+  );
+
+  const roadmap = loadTemplate("roadmap");
+  const horizIdx = roadmap.indexOf("## Horizontal Checklist");
+  const boundaryIdx = roadmap.indexOf("## Boundary Map");
+  assertTrue(
+    horizIdx > 0 && horizIdx < boundaryIdx,
+    "roadmap.md: Horizontal Checklist is before Boundary Map"
+  );
+
+  const milestoneSummary = loadTemplate("milestone-summary");
+  const reqChangesIdx = milestoneSummary.indexOf("## Requirement Changes");
+  const decRevalIdx = milestoneSummary.indexOf("## Decision Re-evaluation");
+  const fwdIntelIdx = milestoneSummary.indexOf("## Forward Intelligence");
+  assertTrue(
+    reqChangesIdx < decRevalIdx && decRevalIdx < fwdIntelIdx,
+    "milestone-summary.md: Decision Re-evaluation is between Requirement Changes and Forward Intelligence"
+  );
+}
+
+report();

package/src/resources/extensions/gsd/tests/queue-completed-milestone-perf.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Regression test for #2379: /gsd queue fails with 429 rate limit on projects
+ * with many completed milestones.
+ *
+ * The bug: buildExistingMilestonesContext iterates over ALL milestones
+ * (including completed ones) and calls loadFile for CONTEXT, SUMMARY,
+ * CONTEXT-DRAFT, and ROADMAP files on each — causing excessive I/O that
+ * triggers rate limits on large projects.
+ *
+ * The fix: completed milestones should emit a short summary line without
+ * loading their heavy artifact files (CONTEXT.md, SUMMARY.md, etc.).
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildExistingMilestonesContext } from "../guided-flow-queue.ts";
+import type { GSDState, MilestoneRegistryEntry } from "../types.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, assertEq, report } = createTestContext();
+
+// ─── Fixture: project with many completed milestones ─────────────────────
+
+const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-perf-"));
+const gsd = join(tmpBase, ".gsd");
+mkdirSync(join(gsd, "milestones"), { recursive: true });
+
+const COMPLETED_COUNT = 25;
+const ACTIVE_COUNT = 1;
+const PENDING_COUNT = 2;
+
+const allMilestoneIds: string[] = [];
+const registry: MilestoneRegistryEntry[] = [];
+
+// Create 25 completed milestones with CONTEXT.md and SUMMARY.md files
+for (let i = 1; i <= COMPLETED_COUNT; i++) {
+  const mid = `M${String(i).padStart(3, "0")}`;
+  allMilestoneIds.push(mid);
+  registry.push({ id: mid, title: `Completed milestone ${i}`, status: "complete" });
+  mkdirSync(join(gsd, "milestones", mid), { recursive: true });
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-CONTEXT.md`),
+    `# ${mid}: Completed milestone ${i}\n\nThis is a large context document for ${mid}.\n${"Lorem ipsum dolor sit amet. ".repeat(50)}\n`,
+  );
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-SUMMARY.md`),
+    `# ${mid} Summary\n\nDelivered feature ${i} successfully.\n`,
+  );
+}
+
+// Create 1 active milestone
+{
+  const mid = `M${String(COMPLETED_COUNT + 1).padStart(3, "0")}`;
+  allMilestoneIds.push(mid);
+  registry.push({ id: mid, title: "Active milestone", status: "active" });
+  mkdirSync(join(gsd, "milestones", mid), { recursive: true });
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-CONTEXT.md`),
+    `# ${mid}: Active milestone\n\nCurrently in progress.\n`,
+  );
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-ROADMAP.md`),
+    `# ${mid} Roadmap\n\nSlices planned.\n`,
+  );
+}
+
+// Create 2 pending milestones
+for (let i = 0; i < PENDING_COUNT; i++) {
+  const mid = `M${String(COMPLETED_COUNT + ACTIVE_COUNT + 1 + i).padStart(3, "0")}`;
+  allMilestoneIds.push(mid);
+  registry.push({ id: mid, title: `Pending milestone ${i + 1}`, status: "pending" });
+  mkdirSync(join(gsd, "milestones", mid), { recursive: true });
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-CONTEXT.md`),
+    `# ${mid}: Pending milestone ${i + 1}\n\nQueued work.\n`,
+  );
+}
+
+const state: GSDState = {
+  activeMilestone: { id: `M${String(COMPLETED_COUNT + 1).padStart(3, "0")}`, title: "Active milestone" },
+  activeSlice: null,
+  activeTask: null,
+  phase: "executing",
+  recentDecisions: [],
+  blockers: [],
+  nextAction: "",
+  registry,
+};
+
+// ─── Test: completed milestones should NOT have their files loaded ────────
+
+console.log("\n=== Queue completed milestone performance (#2379) ===");
+
+const context = await buildExistingMilestonesContext(tmpBase, allMilestoneIds, state);
+
+// Active and pending milestones SHOULD have full context loaded
+const activeMid = `M${String(COMPLETED_COUNT + 1).padStart(3, "0")}`;
+assertTrue(
+  context.includes("Currently in progress"),
+  "Active milestone context content should be loaded",
+);
+assertTrue(
+  context.includes("Slices planned"),
+  "Active milestone roadmap should be loaded",
+);
+
+for (let i = 0; i < PENDING_COUNT; i++) {
+  const mid = `M${String(COMPLETED_COUNT + ACTIVE_COUNT + 1 + i).padStart(3, "0")}`;
+  assertTrue(
+    context.includes(`Pending milestone ${i + 1}`),
+    `Pending milestone ${mid} context should be loaded`,
+  );
+}
+
+// Completed milestones should NOT have their CONTEXT.md body or SUMMARY.md
+// content loaded — only a status line
+for (let i = 1; i <= COMPLETED_COUNT; i++) {
+  const mid = `M${String(i).padStart(3, "0")}`;
+
+  // Should still mention the milestone ID and status
+  assertTrue(
+    context.includes(mid),
+    `Completed milestone ${mid} should still be referenced`,
+  );
+
+  // Should NOT contain the heavy context body text
+  assertTrue(
+    !context.includes(`This is a large context document for ${mid}`),
+    `Completed milestone ${mid} should NOT have its full CONTEXT.md body loaded`,
+  );
+
+  // Should NOT contain the summary body
+  assertTrue(
+    !context.includes(`Delivered feature ${i} successfully`),
+    `Completed milestone ${mid} should NOT have its SUMMARY.md body loaded`,
+  );
+}
+
+// ─── Test: the overall context should be reasonable in size ──────────────
+
+// With 25 completed milestones NOT loading files, the context should be
+// significantly smaller than if all files were loaded
+const contextLines = context.split("\n").length;
+assertTrue(
+  contextLines < 200,
+  `Context should be concise (got ${contextLines} lines); completed milestones should not inflate it`,
+);
+
+// ─── Cleanup ──────────────────────────────────────────────────────────────
+
+rmSync(tmpBase, { recursive: true, force: true });
+
+report();

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

@@ -503,7 +503,8 @@ console.log('\n=== doctor: no blocker → no blocker_discovered_no_replan issue
 // Artifact Resolution: resolveExpectedArtifactPath for replan-slice (#858)
 // ═══════════════════════════════════════════════════════════════════════════
 
-import { resolveExpectedArtifactPath, verifyExpectedArtifact } from '../auto-recovery.ts';
+import { resolveExpectedArtifactPath } from '../auto-artifact-paths.ts';
+import { verifyExpectedArtifact } from '../auto-recovery.ts';
 
 
 describe('replan-slice', () => {

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -184,6 +184,38 @@ test('subdirectory of parent repo gets unique identity after git init (#1639)',
       rmSync(parentRepo, { recursive: true, force: true });
 });
 
+test('ensureGsdSymlink from subdirectory does not create .gsd in subdir when git-root .gsd exists (#2380)', () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-subdir-symlink-")));
+    run("git init -b main", repo);
+    run('git config user.name "Pi Test"', repo);
+    run('git config user.email "pi@example.com"', repo);
+    run('git remote add origin git@github.com:example/subdir-test.git', repo);
+    writeFileSync(join(repo, "README.md"), "# Subdir Test\n", "utf-8");
+    run("git add README.md", repo);
+    run('git commit -m "init"', repo);
+
+    // Set up .gsd symlink at the git root (normal project initialisation)
+    ensureGsdSymlink(repo);
+    assert.ok(existsSync(join(repo, ".gsd")), "root .gsd exists after ensureGsdSymlink");
+    assert.ok(lstatSync(join(repo, ".gsd")).isSymbolicLink(), "root .gsd is a symlink");
+
+    // Create a subdirectory and call ensureGsdSymlink from there
+    const subdir = join(repo, "src", "lib");
+    mkdirSync(subdir, { recursive: true });
+    ensureGsdSymlink(subdir);
+
+    // ensureGsdSymlink should NOT create a .gsd in the subdirectory
+    // because the git root already has a valid .gsd symlink.
+    assert.ok(!existsSync(join(subdir, ".gsd")), "no .gsd created in subdirectory when git-root .gsd exists (#2380)");
+    assert.ok(!existsSync(join(repo, "src", ".gsd")), "no .gsd created in intermediate directory");
+
+    // The root .gsd should still be intact
+    assert.ok(existsSync(join(repo, ".gsd")), "root .gsd still exists");
+    assert.ok(lstatSync(join(repo, ".gsd")).isSymbolicLink(), "root .gsd is still a symlink");
+
+    rmSync(repo, { recursive: true, force: true });
+});
+
 test('validateProjectId rejects invalid values', () => {
     for (const invalid of ["has spaces", "path/traversal", "dot..dot", "back\\slash"]) {
       assert.ok(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -236,6 +236,32 @@ test("parseRoadmapSlices: ## Slices with valid checkboxes does NOT invoke prose
   assert.equal(slices[0]?.done, true);
 });
 
+// ── Regression test for #1940 ───────────────────────────────────────────────
+// '## Slice Roadmap' header is not recognized by extractSlicesSection, causing
+// checkbox-format slices to be missed and all slices reported as incomplete.
+
+test("parseRoadmapSlices: ## Slice Roadmap heading recognized (#1940)", () => {
+  const roadmapContent = [
+    "# M002: Current Milestone", "",
+    "**Vision:** Ship it.", "",
+    "## Slice Roadmap", "",
+    "- [x] **S01: Foundation** `risk:low` `depends:[]`",
+    "  > After this: base layer works.",
+    "- [x] **S02: Core Logic** `risk:medium` `depends:[S01]`",
+    "- [ ] **S03: Polish** `risk:low` `depends:[S01,S02]`", "",
+    "## Boundary Map",
+  ].join("\n");
+  const slices = parseRoadmapSlices(roadmapContent);
+  assert.equal(slices.length, 3, "should parse 3 slices under '## Slice Roadmap'");
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true, "S01 should be marked done");
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, true, "S02 should be marked done");
+  assert.equal(slices[2]?.id, "S03");
+  assert.equal(slices[2]?.done, false, "S03 should be pending");
+  assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
+});
+
 test("parseRoadmapSlices: ## Slices with only non-matching lines returns prose fallback results", () => {
   const weirdContent = `# M020: Odd
 

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -171,7 +171,7 @@ test('(k) run-uat prompt template', () => {
   const milestoneId = 'M001';
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
-  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
+  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
   let promptResult: string | undefined;
@@ -234,7 +234,7 @@ test('(k2) run-uat prompt references gsd_summary_save, not direct write', () =>
     milestoneId: 'M001',
     sliceId: 'S01',
     uatPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
-    uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md',
+    uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
     uatType: 'artifact-driven',
     inlinedContext: '<!-- no context -->',
   });
@@ -265,14 +265,13 @@ test('(l) dispatch preconditions via resolveSliceFile', () => {
         'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
       );
 
-      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assert.deepStrictEqual(
-        uatResultFilePath,
-        null,
-        'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
+      // UAT spec without a verdict line means UAT has not been run yet
+      const rawContent = readFileSync(uatFilePath!, 'utf-8');
+      assert.ok(
+        !/verdict:\s*[\w-]+/i.test(rawContent),
+        'UAT file without verdict indicates UAT has not been run (dispatch trigger state)',
       );
 
-      const rawContent = readFileSync(uatFilePath!, 'utf-8');
       assert.deepStrictEqual(
         extractUatType(rawContent),
         'artifact-driven',
@@ -286,13 +285,18 @@ test('(l) dispatch preconditions via resolveSliceFile', () => {
 test('test block at line 307', () => {
     const base = createFixtureBase();
     try {
-      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '# UAT Result\n\nverdict: PASS\n');
+      // Write UAT file with a verdict — simulates completed UAT
+      writeSliceFile(base, 'M001', 'S01', 'UAT', '# UAT Result\n\nverdict: PASS\n');
 
-      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
+      const uatFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT');
+      assert.ok(
+        uatFilePath !== null,
+        'resolveSliceFile(..., "UAT") returns non-null when UAT file exists',
+      );
+      const content = readFileSync(uatFilePath!, 'utf-8');
       assert.ok(
-        uatResultFilePath !== null,
-        'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
+        /verdict:\s*[\w-]+/i.test(content),
+        'UAT file with verdict indicates UAT has been completed (idempotent skip state)',
       );
     } finally {
       cleanup(base);
@@ -390,7 +394,7 @@ test('(p) run-uat prompt allows PASS when human-only checks remain as NEEDS-HUMA
       milestoneId: 'M001',
       sliceId: 'S01',
       uatPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
-      uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md',
+      uatResultPath: '.gsd/milestones/M001/slices/S01/S01-UAT.md',
       uatType: 'mixed',
       inlinedContext: '<!-- no context -->',
     });
@@ -432,7 +436,7 @@ test('(n) stale replay guard', async () => {
       );
 
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: FAIL\n---\n');
+      writeSliceFile(base, 'M001', 'S01', 'UAT', '---\nverdict: FAIL\n---\n');
 
       const state = {
         activeMilestone: { id: 'M001', title: 'Test roadmap' },
@@ -449,7 +453,7 @@ test('(n) stale replay guard', async () => {
       assert.deepStrictEqual(
         result,
         null,
-        'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
+        'existing UAT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
       );
     } finally {
       cleanup(base);