gsd-pi 2.78.1-dev.82bcf6b71 → 2.78.1-dev.84c045fd2

package/src/resources/extensions/gsd/tests/guided-flow-prompt-consolidation.test.ts

@@ -0,0 +1,133 @@
+/**
+ * GSD2 — regression test for #5183: prompt consolidation.
+ *
+ * The PR removed `guided-execute-task.md` and `guided-complete-slice.md` and
+ * routed `guided-flow.ts` callers to `buildExecuteTaskPrompt` /
+ * `buildCompleteSlicePrompt` from `auto-prompts.ts`. This test exercises the
+ * consolidated builders against a real fixture and asserts they produce
+ * prompts carrying the contract the deleted variants used to enforce:
+ *   - the canonical `gsd_*_complete` tool reference,
+ *   - the explicit working directory binding,
+ *   - the unit identifiers (milestone/slice/task),
+ *   - the quality-gate doctrine that was backported into the canonical files
+ *     (Q8 Operational Readiness for complete-slice).
+ *
+ * Failure of this test means the manual `/gsd` flow no longer matches the
+ * doctrine the auto-mode pipeline relies on — exactly the drift the PR is
+ * supposed to prevent.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  buildExecuteTaskPrompt,
+  buildCompleteSlicePrompt,
+} from "../auto-prompts.ts";
+
+const MID = "M001";
+const SID = "S01";
+const TID = "T01";
+const M_TITLE = "Test milestone";
+const S_TITLE = "Test slice";
+const T_TITLE = "Test task";
+
+describe("guided-flow → auto-prompts consolidation (#5183)", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-prompt-consolidation-"));
+    const sliceDir = join(base, ".gsd", "milestones", MID, "slices", SID);
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+
+    writeFileSync(
+      join(base, ".gsd", "milestones", MID, `${MID}-ROADMAP.md`),
+      "# Roadmap\n- [ ] **S01: Test slice**\n",
+    );
+    writeFileSync(
+      join(sliceDir, `${SID}-PLAN.md`),
+      [
+        "# Slice plan",
+        "",
+        "## Tasks",
+        "- T01: Test task",
+        "",
+        "## Verification",
+        "- All tests pass",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(tasksDir, `${TID}-PLAN.md`),
+      [
+        "# Task plan",
+        "",
+        "## Steps",
+        "1. Implement the thing",
+        "",
+        "## Must-haves",
+        "- Working code",
+      ].join("\n"),
+    );
+  });
+
+  afterEach(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  test("buildExecuteTaskPrompt carries the execute-task contract", async () => {
+    const prompt = await buildExecuteTaskPrompt(MID, SID, S_TITLE, TID, T_TITLE, base);
+
+    assert.ok(prompt.includes(MID), "must mention milestone id");
+    assert.ok(prompt.includes(SID), "must mention slice id");
+    assert.ok(prompt.includes(TID), "must mention task id");
+    assert.ok(prompt.includes(T_TITLE), "must mention task title");
+    assert.ok(
+      prompt.includes("gsd_task_complete"),
+      "must instruct calling the canonical gsd_task_complete tool",
+    );
+    assert.ok(
+      prompt.includes(base),
+      "must bind the explicit working directory absolute path",
+    );
+    assert.ok(
+      prompt.includes("Inlined Task Plan"),
+      "must inline the task plan as the authoritative execution contract",
+    );
+    assert.ok(
+      prompt.includes("Implement the thing"),
+      "must include task plan body content from disk",
+    );
+  });
+
+  test("buildCompleteSlicePrompt carries the complete-slice contract", async () => {
+    const prompt = await buildCompleteSlicePrompt(MID, M_TITLE, SID, S_TITLE, base);
+
+    assert.ok(prompt.includes(MID), "must mention milestone id");
+    assert.ok(prompt.includes(SID), "must mention slice id");
+    assert.ok(prompt.includes(S_TITLE), "must mention slice title");
+    assert.ok(
+      prompt.includes("gsd_slice_complete"),
+      "must instruct calling gsd_slice_complete (was in guided-complete-slice.md)",
+    );
+    assert.ok(
+      prompt.includes(base),
+      "must bind the explicit working directory absolute path",
+    );
+    assert.ok(
+      /Operational Readiness/i.test(prompt),
+      "must reference Q8 Operational Readiness doctrine (backported from guided-complete-slice.md)",
+    );
+    assert.ok(
+      /Slice Summary/i.test(prompt),
+      "must reference the Slice Summary output template",
+    );
+    assert.ok(
+      /UAT/.test(prompt),
+      "must reference the UAT output template",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/handler-worktree-write-isolation.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Regression: when /gsd handlers run with cwd inside a worktree, writes must
+ * land in the worktree's .gsd/, not the parent project's .gsd/.
+ *
+ * The fix in 01464a97 replaced `process.cwd()` with `projectRoot()` to block
+ * $HOME pollution, but `projectRoot()` walks UP from a worktree path to the
+ * outer project root — breaking the worktree isolation invariant agents rely
+ * on. The corrected pattern: handlers use `currentDirectoryRoot()`, which
+ * preserves the active cwd (worktree or project) and still throws when cwd
+ * is $HOME.
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join } from "node:path";
+
+import { currentDirectoryRoot, projectRoot, withCommandCwd, GSDNoProjectError } from "../commands/context.ts";
+
+describe("handlers preserve worktree cwd via currentDirectoryRoot()", () => {
+  let project: string;
+  let worktree: string;
+
+  beforeEach(() => {
+    project = realpathSync(mkdtempSync(join(tmpdir(), "gsd-wt-iso-")));
+    mkdirSync(join(project, ".gsd"), { recursive: true });
+    mkdirSync(join(project, ".git"), { recursive: true });
+    worktree = join(project, ".gsd", "worktrees", "M001");
+    mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(project, { recursive: true, force: true });
+  });
+
+  test("currentDirectoryRoot() returns the worktree path when cwd is the worktree", async () => {
+    const resolved = await withCommandCwd(worktree, async () => currentDirectoryRoot());
+    assert.equal(resolved, worktree, "must keep worktree path so writes isolate");
+  });
+
+  test("projectRoot() walks UP from worktree to the project root (legacy semantics)", async () => {
+    const resolved = await withCommandCwd(worktree, async () => projectRoot());
+    assert.equal(resolved, project, "projectRoot intentionally returns project, not worktree");
+  });
+
+  test("currentDirectoryRoot() throws GSDNoProjectError when cwd is $HOME", async () => {
+    await assert.rejects(
+      withCommandCwd(homedir(), async () => currentDirectoryRoot()),
+      (err: unknown) => err instanceof GSDNoProjectError,
+    );
+  });
+
+  test("currentDirectoryRoot() returns project root when cwd is project root", async () => {
+    const resolved = await withCommandCwd(project, async () => currentDirectoryRoot());
+    assert.equal(resolved, project);
+  });
+});

package/src/resources/extensions/gsd/tests/has-pending-deep-stage.test.ts

@@ -0,0 +1,98 @@
+// gsd-2 / Deep planning mode — Regression coverage for hasPendingDeepStage()
+// being exported and consumed by the showSmartEntry deep-mode kickoff branch.
+//
+// Context: PR #5094 wires a deep-mode branch into showSmartEntry that calls
+// hasPendingDeepStage() to decide whether to hand off to startAutoDetached().
+// Without this guard, /gsd new-project --deep set the planning_depth flag but
+// never actually triggered the staged interview because showSmartEntry fell
+// straight through to the standard milestone wizard. These tests pin the
+// exported contract so the kickoff branch can rely on it.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import { hasPendingDeepStage } from "../auto-dispatch.ts";
+import type { GSDPreferences } from "../preferences.ts";
+import { loadEffectiveGSDPreferences } from "../preferences.ts";
+
+function makeBase(): string {
+  const base = join(tmpdir(), `gsd-deep-pending-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+const lightPrefs: GSDPreferences = { planning_depth: "light" } as GSDPreferences;
+const deepPrefs: GSDPreferences = { planning_depth: "deep" } as GSDPreferences;
+
+test("hasPendingDeepStage: returns false when prefs is undefined (light by omission)", () => {
+  const base = makeBase();
+  try {
+    assert.equal(hasPendingDeepStage(undefined, base), false);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("hasPendingDeepStage: returns false in light mode regardless of artifacts", () => {
+  const base = makeBase();
+  try {
+    assert.equal(hasPendingDeepStage(lightPrefs, base), false);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("hasPendingDeepStage: returns true in deep mode when nothing has been captured", () => {
+  // Fresh project — no PREFERENCES.md frontmatter, no PROJECT.md, no
+  // REQUIREMENTS.md, no research-decision marker. Every gate is pending.
+  const base = makeBase();
+  try {
+    assert.equal(hasPendingDeepStage(deepPrefs, base), true);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("hasPendingDeepStage: returns true in deep mode when only some gates pass", () => {
+  // workflow-preferences captured but PROJECT.md still missing.
+  const base = makeBase();
+  try {
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      "---\nplanning_depth: deep\nworkflow_prefs_captured: true\n---\n",
+    );
+    assert.equal(hasPendingDeepStage(deepPrefs, base), true);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// Regression test for the bug found while debugging /gsd new-project --deep:
+// `planning_depth` was missing from KNOWN_PREFERENCE_KEYS, validatePreferences,
+// and mergePreferences, so it was stripped on every load. The deep-mode flow
+// silently never triggered because every dispatch saw planning_depth: undefined.
+test("loadEffectiveGSDPreferences: planning_depth survives the validate + merge pipeline", () => {
+  const base = makeBase();
+  try {
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      "---\nplanning_depth: deep\n---\n",
+    );
+    const loaded = loadEffectiveGSDPreferences(base);
+    assert.equal(
+      loaded?.preferences?.planning_depth,
+      "deep",
+      "planning_depth must survive load — see KNOWN_PREFERENCE_KEYS, validatePreferences, mergePreferences",
+    );
+    // Cross-check: the dispatch helper reads loaded.preferences, so it must
+    // see the same value. If planning_depth gets stripped anywhere in the
+    // pipeline, hasPendingDeepStage returns false and the deep flow dies.
+    assert.equal(hasPendingDeepStage(loaded?.preferences, base), true);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/init-skip-git.test.ts

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const initWizardSource = readFileSync(join(import.meta.dirname, "..", "init-wizard.ts"), "utf8");
+const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf8");
+
+test("init wizard returns gitEnabled false when git setup is skipped", () => {
+	assert.match(initWizardSource, /gitEnabled = signals\.isGitRepo/);
+	assert.match(initWizardSource, /return \{ completed: true, bootstrapped: true, gitEnabled \}/);
+	assert.match(initWizardSource, /if \(gitEnabled\) \{\s*ensureGitignore\(basePath\);/);
+});
+
+test("guided flow does not initialize git after the init wizard skip-git choice", () => {
+	assert.match(guidedFlowSource, /skipGitBootstrap = result\.gitEnabled === false/);
+	assert.match(guidedFlowSource, /if \(!skipGitBootstrap && \(!nativeIsRepo\(basePath\) \|\| isInheritedRepo\(basePath\)\)\)/);
+	assert.match(guidedFlowSource, /if \(!skipGitBootstrap && nativeIsRepo\(basePath\)\) \{\s*ensureGitignore\(basePath\);/);
+});

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -16,6 +16,7 @@ import { tmpdir } from "node:os";
 // The bootstrap and preferences generation are tested via detection + filesystem checks.
 
 import { detectProjectState } from "../detection.ts";
+import { detectMainBranch } from "../init-wizard.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -205,6 +206,22 @@ test("init-wizard: nativeInit + nativeAddAll + nativeCommit produces a reachable
   assert.equal(subject, "chore: init project");
 });
 
+test("init-wizard: default branch detection does not prefer checked-out feature branch", (t) => {
+  const dir = makeTempDir("git-default-branch");
+  t.after(() => { cleanup(dir); });
+
+  execFileSync("git", ["init"], { cwd: dir });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+  writeFileSync(join(dir, "README.md"), "# test\n", "utf-8");
+  execFileSync("git", ["add", "."], { cwd: dir });
+  execFileSync("git", ["commit", "-m", "init"], { cwd: dir });
+  execFileSync("git", ["branch", "-M", "main"], { cwd: dir });
+  execFileSync("git", ["checkout", "-b", "feature/init"], { cwd: dir });
+
+  assert.equal(detectMainBranch(dir), "main");
+});
+
 test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", (t) => {
   const dir = makeTempDir("both-v1-v2");
   try {

package/src/resources/extensions/gsd/tests/integration/auto-worktree.test.ts

@@ -123,6 +123,7 @@ describe("auto-worktree lifecycle", () => {
 
     // Manually chdir out (simulates pause/crash)
     process.chdir(tempDir);
+    assert.ok(isInAutoWorktree(wtPath2), "isInAutoWorktree honors explicit worktree path when cwd is root");
 
     // enterAutoWorktree should re-enter
     const entered = enterAutoWorktree(tempDir, "M003");

package/src/resources/extensions/gsd/tests/integration/commands-eval-review.integration.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Integration test for `/gsd eval-review` .
+ *
+ * Walks the helper chain end-to-end (parseArgs → detectState → buildContext
+ * → buildPrompt) against a real on-disk slice fixture, then validates the
+ * round-trip: a frontmatter that conforms to the schema described in the
+ * prompt body must parse successfully via the schema validator. This is the
+ * concrete answer to the prior "no end-to-end proof" objection.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  buildEvalReviewContext,
+  buildEvalReviewPrompt,
+  detectEvalReviewState,
+  evalReviewWritePath,
+  MAX_CONTEXT_BYTES,
+  parseEvalReviewArgs,
+} from "../../commands-eval-review.js";
+import { _clearGsdRootCache } from "../../paths.js";
+import {
+  computeOverallScore,
+  deriveCounts,
+  parseEvalReviewFrontmatter,
+} from "../../eval-review-schema.js";
+
+// ─── Fixture content ──────────────────────────────────────────────────────────
+
+const AI_SPEC = [
+  "# AI-SPEC for slice S07: LLM call orchestration",
+  "",
+  "## Required eval dimensions",
+  "",
+  "- observability: every LLM call emits latency + token-count metrics with a trace ID",
+  "- guardrails: requests exceeding the per-session budget cap are rejected",
+  "- tests: golden-file regression suite over canonical prompts",
+  "- metrics: cost roll-up per model + latency P95 per provider",
+  "",
+  "## Tooling",
+  "",
+  "- Logging provider: langfuse (or compatible OpenTelemetry sink)",
+  "- Eval harness: deterministic-prompt fixtures under tests/golden/",
+].join("\n");
+
+const SUMMARY = [
+  "# Slice S07 — implementation summary",
+  "",
+  "Implemented the LLM call wrapper at src/llm/call.ts. Latency is captured",
+  "via emit('llm.latency', { latency_ms, traceId }) on every successful call",
+  "and consumed by the metrics sink at src/metrics/sink.ts:88. Budget cap",
+  "rejection lives in src/llm/budget.ts:42 and has a unit test at",
+  "tests/llm-budget.test.ts that asserts a 401 on cap exceedance.",
+  "",
+  "## Known gaps",
+  "",
+  "- Token-count metric is emitted only for OpenAI; other providers are",
+  "  TODO. tests/golden/ exists but is empty pending the canonical prompt",
+  "  set being finalised.",
+].join("\n");
+
+// ─── Setup helpers ────────────────────────────────────────────────────────────
+
+interface Layout {
+  readonly basePath: string;
+  readonly milestoneId: string;
+  readonly sliceId: string;
+  readonly sliceDir: string;
+}
+
+function buildLayout(opts: { withSpec?: boolean; summaryBytes?: number } = {}): Layout {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-eval-review-int-"));
+  const milestoneId = "M001";
+  const sliceId = "S07";
+  const sliceDir = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId);
+  mkdirSync(sliceDir, { recursive: true });
+  const summary = opts.summaryBytes != null
+    ? "S".repeat(opts.summaryBytes)
+    : SUMMARY;
+  writeFileSync(join(sliceDir, `${sliceId}-SUMMARY.md`), summary, "utf-8");
+  if (opts.withSpec !== false) {
+    writeFileSync(join(sliceDir, `${sliceId}-AI-SPEC.md`), AI_SPEC, "utf-8");
+  }
+  return { basePath, milestoneId, sliceId, sliceDir };
+}
+
+// ─── End-to-end helper-chain pass ─────────────────────────────────────────────
+
+describe("integration: /gsd eval-review helper chain on a real on-disk slice", () => {
+  let layout: Layout;
+  let cwd: string;
+
+  beforeEach(() => {
+    cwd = process.cwd();
+    layout = buildLayout();
+    process.chdir(layout.basePath);
+  });
+
+  afterEach(() => {
+    _clearGsdRootCache();
+    process.chdir(cwd);
+    rmSync(layout.basePath, { recursive: true, force: true });
+  });
+
+  it("walks parseArgs → detect → context → prompt and produces a prompt that contains every required contract anchor", async () => {
+    const args = parseEvalReviewArgs("S07");
+    assert.equal(args.sliceId, "S07");
+
+    const state = detectEvalReviewState(args, layout.basePath, layout.milestoneId);
+    assert.equal(state.kind, "ready");
+    if (state.kind !== "ready") return;
+
+    const ctx = await buildEvalReviewContext(state, layout.milestoneId, () =>
+      new Date("2026-04-28T14:00:00Z"),
+    );
+    assert.equal(ctx.truncated, false);
+    assert.equal(ctx.sliceId, "S07");
+    assert.equal(ctx.outputPath, evalReviewWritePath(layout.sliceDir, "S07"));
+
+    const prompt = buildEvalReviewPrompt(ctx);
+
+    // Schema + rubric anchors
+    assert.ok(prompt.includes("schema: eval-review/v1"));
+    assert.ok(prompt.includes("PRODUCTION_READY"));
+    assert.ok(prompt.includes("NOT_IMPLEMENTED"));
+    assert.ok(prompt.includes("0.6"));
+    assert.ok(prompt.includes("0.4"));
+    assert.ok(prompt.includes("Alternatives considered"));
+    assert.ok(prompt.includes("Anti-Goodhart"));
+
+    // Slice content was inlined verbatim — pick anchors that don't span line breaks.
+    assert.ok(prompt.includes("emit('llm.latency'"));
+    assert.ok(prompt.includes("src/llm/budget.ts:42"));
+    assert.ok(prompt.includes("langfuse"));
+
+    // Output path is the canonical slice file path
+    assert.ok(prompt.includes(`${layout.sliceId}-EVAL-REVIEW.md`));
+  });
+
+  it("falls back to the no-spec audit mode when AI-SPEC.md is absent", async () => {
+    rmSync(layout.basePath, { recursive: true, force: true });
+    layout = buildLayout({ withSpec: false });
+    process.chdir(layout.basePath);
+
+    const args = parseEvalReviewArgs("S07");
+    const state = detectEvalReviewState(args, layout.basePath, layout.milestoneId);
+    assert.equal(state.kind, "ready");
+    if (state.kind !== "ready") return;
+    assert.equal(state.specPath, null);
+
+    const ctx = await buildEvalReviewContext(state, layout.milestoneId);
+    const prompt = buildEvalReviewPrompt(ctx);
+    assert.ok(prompt.toLowerCase().includes("not present"));
+  });
+
+  it("truncates the SUMMARY at MAX_CONTEXT_BYTES and surfaces the truncation note in the prompt (regression: prompt-size cap)", async () => {
+    rmSync(layout.basePath, { recursive: true, force: true });
+    layout = buildLayout({ summaryBytes: MAX_CONTEXT_BYTES + 64 * 1024 });
+    process.chdir(layout.basePath);
+
+    const args = parseEvalReviewArgs("S07");
+    const state = detectEvalReviewState(args, layout.basePath, layout.milestoneId);
+    assert.equal(state.kind, "ready");
+    if (state.kind !== "ready") return;
+
+    const ctx = await buildEvalReviewContext(state, layout.milestoneId);
+    assert.equal(ctx.truncated, true);
+    const prompt = buildEvalReviewPrompt(ctx);
+    assert.ok(prompt.includes("truncated"));
+    assert.ok(prompt.includes("Inputs were truncated"));
+  });
+});
+
+// ─── Round-trip: prompt's described schema → validator ────────────────────────
+
+describe("integration: prompt-schema round-trip", () => {
+  it("synthesizes a frontmatter that matches the prompt's described schema and parses successfully (regression: schema and prompt must not drift)", () => {
+    const fakeContext = {
+      milestoneId: "M001",
+      sliceId: "S07",
+      summary: "fake",
+      summaryPath: "/fake/.gsd/milestones/M001/slices/S07/S07-SUMMARY.md",
+      spec: "fake",
+      specPath: "/fake/.gsd/milestones/M001/slices/S07/S07-AI-SPEC.md",
+      outputPath: "/fake/.gsd/milestones/M001/slices/S07/S07-EVAL-REVIEW.md",
+      relativeOutputPath: ".gsd/milestones/M001/slices/S07/S07-EVAL-REVIEW.md",
+      truncated: false,
+      generatedAt: "2026-04-28T14:00:00Z",
+    } as const;
+    const prompt = buildEvalReviewPrompt(fakeContext);
+
+    // Build a frontmatter that should be the LLM's output if it follows
+    // the prompt instructions verbatim, then validate it.
+    const coverage = 78;
+    const infrastructure = 92;
+    const overall = computeOverallScore(coverage, infrastructure);
+    const gaps = [
+      {
+        id: "G01",
+        dimension: "metrics",
+        severity: "minor",
+        description: "Token-count metric only emitted for OpenAI provider.",
+        evidence: "src/llm/call.ts:71 — emit happens inside the OpenAI branch only",
+        suggested_fix: "Move emit('llm.tokens') above the provider switch in src/llm/call.ts",
+      },
+    ];
+    const counts = deriveCounts(gaps as never);
+
+    const frontmatter = [
+      "---",
+      "schema: eval-review/v1",
+      "verdict: PRODUCTION_READY",
+      `coverage_score: ${coverage}`,
+      `infrastructure_score: ${infrastructure}`,
+      `overall_score: ${overall}`,
+      "generated: 2026-04-28T14:00:00Z",
+      "slice: S07",
+      "milestone: M001",
+      "gaps:",
+      `  - id: ${gaps[0]!.id}`,
+      `    dimension: ${gaps[0]!.dimension}`,
+      `    severity: ${gaps[0]!.severity}`,
+      `    description: "${gaps[0]!.description}"`,
+      `    evidence: "${gaps[0]!.evidence}"`,
+      `    suggested_fix: "${gaps[0]!.suggested_fix}"`,
+      "counts:",
+      `  blocker: ${counts.blocker}`,
+      `  major: ${counts.major}`,
+      `  minor: ${counts.minor}`,
+      "---",
+      "",
+      "# Free-form analysis below",
+      "Detailed prose for human reviewers.",
+    ].join("\n");
+
+    const parsed = parseEvalReviewFrontmatter(frontmatter);
+    assert.equal(parsed.ok, true, parsed.ok ? "" : `${parsed.error} at ${parsed.pointer}`);
+    if (parsed.ok) {
+      assert.equal(parsed.data.verdict, "PRODUCTION_READY");
+      assert.equal(parsed.data.overall_score, overall);
+      assert.equal(parsed.data.gaps.length, 1);
+      assert.equal(parsed.data.gaps[0]!.dimension, "metrics");
+    }
+
+    // Cross-check: the prompt body must reference the same schema version
+    // the validator accepts. If a future patch changes either side without
+    // the other, this assertion catches the drift.
+    assert.ok(prompt.includes("schema: eval-review/v1"));
+  });
+});

package/src/resources/extensions/gsd/tests/integration/doctor-runtime.test.ts

@@ -124,6 +124,46 @@ describe('doctor-runtime', async () => {
       assert.deepStrictEqual(Object.keys(content.cycleCounts).length, 0, "hook state cycle counts cleared");
     });
 
+    // ─── Test 3b: Exhausted run-uat retry counter detection & fix ──────
+    test('uat_retry_exhausted', async () => {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      const runtimeDir = join(dir, ".gsd", "runtime");
+      mkdirSync(runtimeDir, { recursive: true });
+      const counterPath = join(runtimeDir, "uat-count-M001-S01.json");
+      writeFileSync(counterPath, JSON.stringify({ count: 7, updatedAt: "2026-04-30T00:00:00.000Z" }));
+
+      const detect = await runGSDDoctor(dir);
+      const uatIssues = detect.issues.filter(i => i.code === "uat_retry_exhausted");
+      assert.ok(uatIssues.length > 0, "detects exhausted UAT retry counter");
+      assert.equal(uatIssues[0]?.unitId, "M001/S01", "issue is scoped to the stuck slice");
+      assert.ok(uatIssues[0]?.fixable === true, "exhausted UAT counter is fixable");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes("reset exhausted run-uat retry counter for M001/S01")),
+        "fix resets the UAT retry counter",
+      );
+      assert.ok(!existsSync(counterPath), "UAT retry counter removed after fix");
+    });
+
+    test('uat_retry_exhausted — no issue when ASSESSMENT has verdict', async () => {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      const runtimeDir = join(dir, ".gsd", "runtime");
+      mkdirSync(runtimeDir, { recursive: true });
+      writeFileSync(join(runtimeDir, "uat-count-M001-S01.json"), JSON.stringify({ count: 7 }));
+
+      const assessmentPath = join(dir, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
+      writeFileSync(assessmentPath, "---\nverdict: PASS\n---\n# UAT Result\n");
+
+      const detect = await runGSDDoctor(dir);
+      const uatIssues = detect.issues.filter(i => i.code === "uat_retry_exhausted");
+      assert.deepStrictEqual(uatIssues.length, 0, "does not flag stale counter when ASSESSMENT already has a verdict");
+    });
+
     // ─── Test 4: Activity log bloat detection ─────────────────────────
     test('activity_log_bloat', async () => {
       const dir = createMinimalProject();