gsd-pi 2.71.0-dev.06b86c6 → 2.71.0-dev.246c32d

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

@@ -12,7 +12,7 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync, readFileSync, symlinkSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -44,6 +44,27 @@ function createTempRepo(): string {
   return dir;
 }
 
+function createTempRepoWithExternalGsd(): { repo: string; externalState: string } {
+  const realTmp = realpathSync(tmpdir());
+  const repo = realpathSync(mkdtempSync(join(realTmp, "wt-ms-merge-ext-test-")));
+  const externalState = realpathSync(mkdtempSync(join(realTmp, "wt-ms-merge-ext-state-")));
+
+  run("git init", repo);
+  run("git config user.email test@test.com", repo);
+  run("git config user.name Test", repo);
+
+  mkdirSync(join(externalState, "worktrees"), { recursive: true });
+  symlinkSync(externalState, join(repo, ".gsd"));
+
+  writeFileSync(join(repo, "README.md"), "# test\n");
+  writeFileSync(join(externalState, "STATE.md"), "# State\n");
+  run("git add .", repo);
+  run("git commit -m init", repo);
+  run("git branch -M main", repo);
+
+  return { repo, externalState };
+}
+
 /** Minimal roadmap content for mergeMilestoneToMain. */
 function makeRoadmap(milestoneId: string, title: string, slices: Array<{ id: string; title: string }>): string {
   const sliceLines = slices.map(s => `- [x] **${s.id}: ${s.title}**`).join("\n");
@@ -87,6 +108,12 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     return d;
   }
 
+  function freshRepoWithExternalGsd(): { repo: string; externalState: string } {
+    const { repo, externalState } = createTempRepoWithExternalGsd();
+    tempDirs.push(repo, externalState);
+    return { repo, externalState };
+  }
+
   afterEach(() => {
     process.chdir(savedCwd);
     for (const d of tempDirs) {
@@ -638,6 +665,44 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be false when only .gsd/ files were merged");
   });
 
+  test("#2156: mergeMilestoneToMain removes external-state worktrees using the milestone branch name", () => {
+    const { repo, externalState } = freshRepoWithExternalGsd();
+    const wtPath = createAutoWorktree(repo, "M215");
+
+    addSliceToMilestone(repo, wtPath, "M215", "S01", "External cleanup", [
+      { file: "external-cleanup.ts", content: "export const externalCleanup = true;\n", message: "add external cleanup" },
+    ]);
+
+    const realWtPath = realpathSync(wtPath);
+    assert.ok(
+      realWtPath.startsWith(externalState),
+      `worktree should be registered under external .gsd state, got ${realWtPath}`,
+    );
+
+    // Recreate the exact divergence from #1852: local .gsd/ is replaced with a
+    // stale real directory, so worktreePath() no longer matches git's record.
+    unlinkSync(join(repo, ".gsd"));
+    mkdirSync(join(repo, ".gsd", "worktrees", "M215"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "STATE.md"), "# Local stale state\n");
+    writeFileSync(join(repo, ".gsd", "worktrees", "M215", "stale.txt"), "stale local artifact\n");
+
+    const roadmap = makeRoadmap("M215", "External cleanup", [
+      { id: "S01", title: "External cleanup" },
+    ]);
+
+    mergeMilestoneToMain(repo, "M215", roadmap);
+
+    assert.ok(
+      !run("git worktree list", repo).includes("M215"),
+      "merged milestone worktree should be removed from git worktree list",
+    );
+    assert.ok(!existsSync(realWtPath), "real external worktree directory should be removed");
+    assert.ok(
+      !run("git branch", repo).includes("milestone/M215"),
+      "milestone branch should be deleted after merge cleanup",
+    );
+  });
+
   test("#2912: MERGE_HEAD cleaned up after squash-merge conflict", () => {
     const repo = freshRepo();
     const wtPath = createAutoWorktree(repo, "M291");

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -1,6 +1,6 @@
 /**
  * Tests for model config isolation between concurrent instances (#650, #1065)
- * and GSD preferences override of settings.json defaults (#3517).
+ * and session-scoped model precedence behavior.
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -157,75 +157,60 @@ describe("session model recovery on error (#1065)", () => {
   });
 });
 
-// ─── GSD Preferences override settings.json (#3517) ─────────────────────────
+// ─── Manual session model override precedence ───────────────────────────────
 
-describe("GSD preferences override settings.json for session model (#3517)", () => {
-  it("preferredModel takes priority over ctx.model when both are available", () => {
-    // Simulates auto-start.ts logic: preferredModel ?? ctx.model snapshot
-    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" };
-    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+describe("manual session model override precedence", () => {
+  it("manual session override takes priority over preferences and ctx.model", () => {
+    const manualSessionOverride = { provider: "openai-codex", id: "gpt-5.4" };
+    const preferredModel = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    const ctxModel = { provider: "claude-code", id: "claude-opus-4-6" };
 
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
       ?? { provider: ctxModel.provider, id: ctxModel.id };
 
-    assert.equal(startModelSnapshot.provider, "openai-codex",
-      "preferredModel provider should win over ctx.model");
-    assert.equal(startModelSnapshot.id, "gpt-5.4",
-      "preferredModel id should win over ctx.model");
+    assert.equal(startModelSnapshot.provider, "openai-codex");
+    assert.equal(startModelSnapshot.id, "gpt-5.4");
+  });
+
+  it("falls back to preferences when no manual override is active", () => {
+    const manualSessionOverride: { provider: string; id: string } | undefined = undefined;
+    const preferredModel = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    const ctxModel = { provider: "claude-code", id: "claude-opus-4-6" };
+
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
+      ?? { provider: ctxModel.provider, id: ctxModel.id };
+
+    assert.equal(startModelSnapshot.provider, "anthropic");
+    assert.equal(startModelSnapshot.id, "claude-sonnet-4-6");
   });
 
-  it("falls back to ctx.model when no GSD preferences are configured", () => {
+  it("falls back to ctx.model when no manual override or preferences are configured", () => {
+    const manualSessionOverride: { provider: string; id: string } | undefined = undefined;
     const preferredModel: { provider: string; id: string } | undefined = undefined;
-    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+    const ctxModel = { provider: "claude-code", id: "claude-opus-4-6" };
 
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
       ?? { provider: ctxModel.provider, id: ctxModel.id };
 
-    assert.equal(startModelSnapshot.provider, "claude-code",
-      "should fall back to ctx.model provider when no preferences");
-    assert.equal(startModelSnapshot.id, "claude-sonnet-4-6",
-      "should fall back to ctx.model id when no preferences");
+    assert.equal(startModelSnapshot.provider, "claude-code");
+    assert.equal(startModelSnapshot.id, "claude-opus-4-6");
   });
 
-  it("handles null ctx.model with no preferences gracefully", () => {
+  it("handles null ctx.model with no override or preferences gracefully", () => {
+    const manualSessionOverride: { provider: string; id: string } | undefined = undefined;
     const preferredModel: { provider: string; id: string } | undefined = undefined;
     // Use a function to prevent TS from narrowing to `never` in the ternary
     function getCtxModel(): { provider: string; id: string } | null { return null; }
     const ctxModel = getCtxModel();
 
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
       ?? (ctxModel ? { provider: ctxModel.provider, id: ctxModel.id } : null);
 
     assert.equal(startModelSnapshot, null,
-      "should be null when neither preferences nor ctx.model exist");
-  });
-
-  it("bare model ID uses session provider when available", () => {
-    // Simulates: PREFERENCES.md has "gpt-5.4" (no provider), session is openai-codex
-    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" }; // from resolveDefaultSessionModel("openai-codex")
-    const ctxModel = { provider: "openai-codex", id: "claude-sonnet-4-6" };
-
-    const startModelSnapshot = preferredModel
-      ?? { provider: ctxModel.provider, id: ctxModel.id };
-
-    assert.equal(startModelSnapshot.provider, "openai-codex");
-    assert.equal(startModelSnapshot.id, "gpt-5.4",
-      "bare model ID from preferences should still override ctx.model");
-  });
-
-  it("stale settings.json does not leak when preferences are set", () => {
-    // Scenario: settings.json has claude-code, PREFERENCES.md has openai-codex
-    const settingsJsonDefault = { provider: "claude-code", id: "claude-sonnet-4-6" };
-    const preferencesModel = { provider: "openai-codex", id: "gpt-5.4" };
-
-    // auto-start.ts captures preferredModel first, which preempts settingsJsonDefault
-    const startModelSnapshot = preferencesModel ?? settingsJsonDefault;
-
-    assert.equal(startModelSnapshot.provider, "openai-codex",
-      "PREFERENCES.md must override stale settings.json provider");
-    assert.equal(startModelSnapshot.id, "gpt-5.4",
-      "PREFERENCES.md must override stale settings.json model");
-    assert.notEqual(startModelSnapshot.provider, settingsJsonDefault.provider,
-      "settings.json provider must NOT leak through");
+      "should be null when no model source is available");
   });
 });

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -16,6 +16,7 @@ import {
   getLineCount,
   suppressPersistence,
   unsuppressPersistence,
+  onNotificationStoreChange,
   _resetNotificationStore,
 } from "../notification-store.js";
 
@@ -296,4 +297,21 @@ describe("notification-store", () => {
 
     rmSync(lockPath, { force: true });
   });
+
+  test("listeners are notified on append, markAllRead, and clear", () => {
+    initNotificationStore(tmp);
+    let calls = 0;
+    const unsubscribe = onNotificationStoreChange(() => { calls++; });
+
+    appendNotification("msg1", "info");
+    assert.equal(calls, 1, "append should emit one change");
+
+    markAllRead();
+    assert.equal(calls, 2, "markAllRead should emit one change when state changes");
+
+    clearNotifications();
+    assert.equal(calls, 3, "clear should emit one change");
+
+    unsubscribe();
+  });
 });

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -7,7 +7,7 @@ import { tmpdir } from "node:os";
 import { initNotificationStore, appendNotification, _resetNotificationStore } from "../notification-store.js";
 import { buildNotificationWidgetLines } from "../notification-widget.js";
 
-test("buildNotificationWidgetLines includes slash-command fallback for unread notifications", () => {
+test("buildNotificationWidgetLines shows unread count with shortcut pair", () => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-notification-widget-"));
   try {
     mkdirSync(join(tmp, ".gsd"), { recursive: true });
@@ -17,7 +17,8 @@ test("buildNotificationWidgetLines includes slash-command fallback for unread no
 
     const lines = buildNotificationWidgetLines();
     assert.equal(lines.length, 1);
-    assert.match(lines[0]!, /\/gsd notifications/);
+    assert.match(lines[0]!, /Notifications:\s+1 unread/);
+    assert.match(lines[0]!, /\(.+\/.+\)/);
   } finally {
     _resetNotificationStore();
     rmSync(tmp, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/notifications-handler.test.ts

@@ -0,0 +1,90 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdirSync, rmSync } from "node:fs";
+
+import { handleNotificationsCommand } from "../commands/handlers/notifications-handler.ts";
+import {
+  _resetNotificationStore,
+  appendNotification,
+  initNotificationStore,
+} from "../notification-store.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-notifications-handler-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function cleanup(dir: string): void {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // best-effort
+  }
+}
+
+test("notifications command falls back to text output when overlay returns undefined", async (t) => {
+  const base = makeTempDir("overlay-fallback");
+  initNotificationStore(base);
+  appendNotification("Build complete", "success");
+
+  t.after(() => {
+    _resetNotificationStore();
+    cleanup(base);
+  });
+
+  const notices: Array<{ message: string; level?: string }> = [];
+  await handleNotificationsCommand(
+    "",
+    {
+      hasUI: true,
+      ui: {
+        custom: async () => undefined,
+        notify: (message: string, level?: string) => {
+          notices.push({ message, level });
+        },
+      },
+    } as any,
+    {} as any,
+  );
+
+  assert.equal(notices.length, 1, "text fallback should be emitted when overlay cannot render");
+  assert.match(notices[0].message, /Recent notifications:/);
+});
+
+test("notifications tail caps inline output and hints to open overlay", async (t) => {
+  const base = makeTempDir("tail-cap");
+  initNotificationStore(base);
+  for (let i = 0; i < 55; i++) {
+    appendNotification(`notification-${i + 1}`, "info");
+  }
+
+  t.after(() => {
+    _resetNotificationStore();
+    cleanup(base);
+  });
+
+  const notices: Array<{ message: string; level?: string }> = [];
+  await handleNotificationsCommand(
+    "tail 200",
+    {
+      hasUI: true,
+      ui: {
+        notify: (message: string, level?: string) => {
+          notices.push({ message, level });
+        },
+      },
+    } as any,
+    {} as any,
+  );
+
+  assert.equal(notices.length, 1);
+  assert.match(notices[0].message, /Last 40 notification\(s\):/);
+  assert.match(notices[0].message, /\.\.\. and \d+ more \(open \/gsd notifications to browse all\)/);
+});

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -56,6 +56,7 @@ describe("parallel-monitor-overlay", () => {
     overlay2.handleInput("q");
     assert.ok(closed, "pressing q should trigger onClose");
     overlay2.dispose();
+
   });
 
   it("ParallelMonitorOverlay clamps scrollOffset during render", async () => {

package/src/resources/extensions/gsd/tests/park-db-sync.test.ts

@@ -69,6 +69,24 @@ test("unparkMilestone updates DB status to 'active' (#2694)", () => {
   }
 });
 
+test("unparkMilestone repairs parked DB state when PARKED.md is missing (#3707)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "parked" });
+
+    const unparked = unparkMilestone(base, "M001");
+
+    assert.ok(unparked, "unparkMilestone should recover DB-only parked state");
+    assert.equal(getMilestone("M001")!.status, "active", "DB status should be repaired to active");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("park/unpark are safe when DB is not available (#2694 guard)", () => {
   const base = createBase();
   try {

package/src/resources/extensions/gsd/tests/prompt-system-gate-coverage.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Prompt-system gate coverage tests.
+ *
+ * These tests pin the invariants the plan file documents:
+ *   1. Every pending slice-scoped gate is routed to exactly one owner turn.
+ *      Q8 (owned by complete-slice) MUST NOT leak into gate-evaluate and
+ *      get silently dropped the way it used to before the registry landed.
+ *   2. getPendingGatesForTurn filters by the registry's owner turn, not
+ *      just the DB scope column.
+ *   3. Output validators recognize artifacts that contain the required
+ *      gate section headings, and flag ones that don't.
+ *   4. Prompt output produced by the validators reflects MV01-MV04.
+ *
+ * They also assert the VALIDATION.md renderer still produces headings
+ * matching the registry's promptSection strings, so future renderer
+ * edits that drift from the registry fail the suite loudly.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  insertGateRow,
+  getPendingGates,
+  getPendingGatesForTurn,
+} from "../gsd-db.ts";
+import {
+  GATE_REGISTRY,
+  getGatesForTurn,
+  type OwnerTurn,
+} from "../gate-registry.ts";
+import {
+  validateSliceSummaryOutput,
+  validateTaskSummaryOutput,
+  validateMilestoneValidationOutput,
+  validateGateSections,
+} from "../prompt-validation.ts";
+
+function setupTestDb(): string {
+  const tmpDir = mkdtempSync(join(tmpdir(), "prompt-gate-coverage-"));
+  const dbPath = join(tmpDir, "gsd.db");
+  openDatabase(dbPath);
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    milestoneId: "M001",
+    id: "S01",
+    title: "Test Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Test Task",
+    status: "pending",
+  });
+  return tmpDir;
+}
+
+describe("getPendingGatesForTurn routes by owner turn, not scope column", () => {
+  let tmpDir: string;
+  beforeEach(() => {
+    tmpDir = setupTestDb();
+  });
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("Q8 stored as scope:'slice' is owned by complete-slice, not gate-evaluate", () => {
+    // Seed the three slice-scoped gates plan-slice writes today.
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q8", scope: "slice" });
+
+    // getPendingGates(..., "slice") returns all three (unchanged).
+    const allSlicePending = getPendingGates("M001", "S01", "slice");
+    assert.equal(allSlicePending.length, 3);
+
+    // But the turn-aware helper routes them correctly.
+    const gateEval = getPendingGatesForTurn("M001", "S01", "gate-evaluate");
+    assert.deepEqual(gateEval.map((g) => g.gate_id).sort(), ["Q3", "Q4"]);
+
+    const completeSlice = getPendingGatesForTurn("M001", "S01", "complete-slice");
+    assert.deepEqual(completeSlice.map((g) => g.gate_id), ["Q8"]);
+  });
+
+  test("task-scoped gates are scoped to the requested task id", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q6", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T02" });
+
+    const t1 = getPendingGatesForTurn("M001", "S01", "execute-task", "T01");
+    assert.equal(t1.length, 2);
+    assert.ok(t1.every((g) => g.gate_id === "Q5" || g.gate_id === "Q6"));
+
+    const t2 = getPendingGatesForTurn("M001", "S01", "execute-task", "T02");
+    assert.equal(t2.length, 1);
+    assert.equal(t2[0].gate_id, "Q5");
+  });
+});
+
+describe("per-turn output validators", () => {
+  test("validateSliceSummaryOutput flags missing Operational Readiness", () => {
+    const md = `# S01: Test Slice\n\n## What Happened\nstuff\n\n## Verification\nstuff\n`;
+    const result = validateSliceSummaryOutput(md);
+    assert.equal(result.valid, false);
+    assert.ok(result.missing.some((m) => m.includes("Q8")));
+    assert.ok(result.missing.some((m) => m.includes("Operational Readiness")));
+  });
+
+  test("validateSliceSummaryOutput passes when Operational Readiness heading is present", () => {
+    const md = `# S01\n\n## Operational Readiness\n- Health: /health\n- Failure: alert\n`;
+    const result = validateSliceSummaryOutput(md);
+    assert.equal(result.valid, true);
+    assert.equal(result.missing.length, 0);
+  });
+
+  test("validateMilestoneValidationOutput requires all four MV headings", () => {
+    // Missing Requirement Coverage.
+    const md = [
+      "# Milestone Validation: M001",
+      "## Success Criteria Checklist",
+      "ok",
+      "## Slice Delivery Audit",
+      "ok",
+      "## Cross-Slice Integration",
+      "ok",
+    ].join("\n\n");
+    const result = validateMilestoneValidationOutput(md);
+    assert.equal(result.valid, false);
+    assert.ok(result.missing.some((m) => m.includes("MV04")));
+  });
+
+  test("validateMilestoneValidationOutput passes for a complete VALIDATION.md", () => {
+    const md = [
+      "# Milestone Validation: M001",
+      "## Success Criteria Checklist",
+      "ok",
+      "## Slice Delivery Audit",
+      "ok",
+      "## Cross-Slice Integration",
+      "ok",
+      "## Requirement Coverage",
+      "ok",
+    ].join("\n\n");
+    const result = validateMilestoneValidationOutput(md);
+    assert.equal(result.valid, true, `unexpected missing: ${result.missing.join(", ")}`);
+  });
+
+  test("validateTaskSummaryOutput flags missing task-gate sections", () => {
+    const md = `# T01\n\n## What Happened\nstuff\n\n## Verification\nstuff\n`;
+    const result = validateTaskSummaryOutput(md);
+    assert.equal(result.valid, false);
+    const idsInMissing = result.missing.join(" ");
+    assert.ok(idsInMissing.includes("Q5"));
+    assert.ok(idsInMissing.includes("Q6"));
+    assert.ok(idsInMissing.includes("Q7"));
+  });
+
+  test("validateGateSections returns empty missing when gate bucket is empty", () => {
+    // Build a phoney owner turn that owns nothing (simulate by validating
+    // against a real turn against an artifact containing every section).
+    const fullMd = getGatesForTurn("validate-milestone")
+      .map((g) => `## ${g.promptSection}\n\nstuff`)
+      .join("\n\n");
+    const result = validateGateSections(fullMd, "validate-milestone");
+    assert.equal(result.valid, true);
+  });
+});
+
+describe("registry / renderer parity", () => {
+  test("MV promptSections match the validate-milestone renderer H2 headings", () => {
+    // Mirror the string literals from tools/validate-milestone.ts
+    // renderValidationMarkdown() so a rename there flips this test red.
+    const expectedHeadings = [
+      "Success Criteria Checklist",
+      "Slice Delivery Audit",
+      "Cross-Slice Integration",
+      "Requirement Coverage",
+    ];
+    const registryHeadings = getGatesForTurn("validate-milestone").map((g) => g.promptSection);
+    assert.deepEqual(registryHeadings.sort(), [...expectedHeadings].sort());
+  });
+
+  test("Q8 promptSection matches the complete-slice renderer H2 heading", () => {
+    // Mirror the slice-summary H2 introduced in tools/complete-slice.ts.
+    assert.equal(GATE_REGISTRY.Q8.promptSection, "Operational Readiness");
+  });
+
+  test("registry owner turns cover every turn gate-registry.ts declares", () => {
+    const ownerTurns = new Set<OwnerTurn>(Object.values(GATE_REGISTRY).map((g) => g.ownerTurn));
+    assert.ok(ownerTurns.has("gate-evaluate"));
+    assert.ok(ownerTurns.has("execute-task"));
+    assert.ok(ownerTurns.has("complete-slice"));
+    assert.ok(ownerTurns.has("validate-milestone"));
+  });
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -32,6 +32,15 @@ test("classifyError detects rate limit from message", () => {
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats OpenRouter affordability errors as transient rate-limit class", () => {
+  const result = classifyError(
+    "402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+  );
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
 test("classifyError extracts reset delay from message", () => {
   const result = classifyError("rate limit exceeded, reset in 45s");
   assert.equal(result.kind, "rate-limit");