gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -225,6 +225,81 @@ test("slice_parallel numeric max_workers is bounded to 1..8", () => {
   assert.ok(tooHigh.errors.some(e => e.includes("slice_parallel.max_workers")));
 });
 
+test("workspace.repositories validates and is preserved", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: {
+          path: "frontend",
+          role: "web UI",
+          verification: ["npm test"],
+          commit_policy: "skip",
+        },
+        backend: {
+          path: "backend",
+          role: "API",
+        },
+      },
+    },
+  });
+
+  assert.equal(errors.length, 0);
+  assert.equal(warnings.filter(w => w.includes("workspace")).length, 0);
+  assert.equal(preferences.workspace?.mode, "parent");
+  assert.deepEqual(preferences.workspace?.repositories?.frontend, {
+    path: "frontend",
+    role: "web UI",
+    verification: ["npm test"],
+    commit_policy: "skip",
+  });
+  assert.deepEqual(preferences.workspace?.repositories?.backend, {
+    path: "backend",
+    role: "API",
+  });
+});
+
+test("workspace.repositories.commit_policy rejects invalid values", () => {
+  const { errors } = validatePreferences({
+    workspace: {
+      repositories: {
+        frontend: {
+          path: "frontend",
+          commit_policy: "manual",
+        },
+      },
+    },
+  } as any);
+
+  assert.ok(errors.some((e) => e.includes("workspace.repositories.frontend.commit_policy")));
+});
+
+test("workspace.repositories rejects invalid shapes", () => {
+  const { errors } = validatePreferences({
+    workspace: {
+      mode: "invalid-mode",
+      repositories: {
+        "bad id": { path: "frontend" },
+        backend: { path: "" },
+      },
+    },
+  } as any);
+
+  assert.ok(errors.some(e => e.includes("workspace.mode")));
+  assert.ok(errors.some(e => e.includes('workspace.repositories key "bad id"')));
+  assert.ok(errors.some(e => e.includes("workspace.repositories.backend.path")));
+});
+
+test("workspace is a recognized preference key (no unknown warning)", () => {
+  const { warnings } = validatePreferences({
+    workspace: { mode: "project" },
+  });
+  assert.equal(
+    warnings.filter(w => w.includes("unknown preference key \"workspace\"")).length,
+    0,
+  );
+});
+
 test("valid values pass through correctly", () => {
   const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
   assert.equal(p1.budget_enforcement, "halt");

package/src/resources/extensions/gsd/tests/prefs-missing-models-crash.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Regression coverage for the `/gsd setup prefs` crash:
+ *   "Cannot read properties of undefined (reading 'models')"
+ *
+ * Originally caused by unsafe `prefs?.preferences.models` access (optional-
+ * chained on `prefs` only, not on `preferences`) plus a wizard entrypoint
+ * that did not normalize partially-formed preference shapes. These tests
+ * pin the new behavior so future refactors cannot silently re-introduce the
+ * crash.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { normalizePreferencesShape } from "../preferences.ts";
+import {
+  resolveDefaultSessionModel,
+  resolveModelWithFallbacksForUnit,
+} from "../preferences-models.ts";
+import { buildCategorySummaries, handlePrefsWizard } from "../commands-prefs-wizard.ts";
+import { readModelFromPreferences } from "../watch/header-renderer.ts";
+
+// ─── normalizePreferencesShape ─────────────────────────────────────────────
+
+test("normalizePreferencesShape: null/undefined/non-object → empty object", () => {
+  assert.deepEqual(normalizePreferencesShape(null), {});
+  assert.deepEqual(normalizePreferencesShape(undefined), {});
+  assert.deepEqual(normalizePreferencesShape("nope"), {});
+  assert.deepEqual(normalizePreferencesShape(42), {});
+});
+
+test("normalizePreferencesShape: wrapper with preferences=undefined → empty object", () => {
+  assert.deepEqual(
+    normalizePreferencesShape({ path: "/x", scope: "global", preferences: undefined }),
+    {},
+  );
+});
+
+test("normalizePreferencesShape: full wrapper unwraps to a fresh bare prefs object", () => {
+  const wrapper = {
+    path: "/x",
+    scope: "global" as const,
+    preferences: { mode: "team" as string, models: { execution: "p/m" } },
+  };
+  const out = normalizePreferencesShape(wrapper);
+  assert.deepEqual(out, { mode: "team", models: { execution: "p/m" } });
+  // Mutating the result must not bleed into the wrapper.
+  out.mode = "solo";
+  assert.equal(wrapper.preferences.mode, "team");
+});
+
+test("normalizePreferencesShape: bare prefs object pass-through (no `preferences` key)", () => {
+  const bare = { mode: "solo" as string, models: { planning: "p/m" } };
+  const out = normalizePreferencesShape(bare);
+  assert.deepEqual(out, bare);
+  out.mode = "team";
+  assert.equal(bare.mode, "solo");
+});
+
+// ─── buildCategorySummaries on missing models ──────────────────────────────
+
+test("buildCategorySummaries({}) reports models as not configured without throwing", () => {
+  const summaries = buildCategorySummaries({});
+  assert.equal(summaries.models, "(not configured)");
+});
+
+// ─── Model resolvers tolerate missing/partial preference shapes ────────────
+
+function withGsdHome(content: string | null, fn: () => void): void {
+  const oldHome = process.env.GSD_HOME;
+  const home = mkdtempSync(join(tmpdir(), "gsd-prefs-missing-"));
+  try {
+    process.env.GSD_HOME = home;
+    if (content !== null) {
+      writeFileSync(join(home, "PREFERENCES.md"), content);
+    }
+    fn();
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+test("resolveModelWithFallbacksForUnit returns undefined when no preferences file exists", () => {
+  withGsdHome(null, () => {
+    assert.equal(resolveModelWithFallbacksForUnit("execute-task"), undefined);
+  });
+});
+
+test("resolveModelWithFallbacksForUnit returns undefined when preferences omit models", () => {
+  withGsdHome("---\nmode: solo\n---\n", () => {
+    assert.equal(resolveModelWithFallbacksForUnit("execute-task"), undefined);
+  });
+});
+
+test("resolveDefaultSessionModel returns undefined when no preferences file exists", () => {
+  withGsdHome(null, () => {
+    assert.equal(resolveDefaultSessionModel("anthropic"), undefined);
+  });
+});
+
+test("resolveDefaultSessionModel returns undefined when preferences omit models", () => {
+  withGsdHome("---\nmode: solo\n---\n", () => {
+    assert.equal(resolveDefaultSessionModel("anthropic"), undefined);
+  });
+});
+
+test("readModelFromPreferences returns 'default' when preferences omit models", () => {
+  withGsdHome("---\nmode: solo\n---\n", () => {
+    assert.equal(readModelFromPreferences(), "default");
+  });
+});
+
+// ─── End-to-end wizard: no existing prefs + immediate Save & Exit ──────────
+
+test("handlePrefsWizard works with no existing preferences and Save & Exit", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-empty-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  try {
+    let saveExitReturned = false;
+    const ctx = {
+      ui: {
+        notify() {},
+        select: async () => {
+          saveExitReturned = true;
+          return "── Save & Exit ──";
+        },
+      },
+      waitForIdle: async () => {},
+      reload: async () => {},
+    } as any;
+
+    await handlePrefsWizard(ctx, "project", undefined, { pathOverride: prefsPath });
+    assert.ok(saveExitReturned, "wizard should have prompted for category selection");
+
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.match(saved, /^---\n/, "saved file must start with frontmatter");
+    assert.match(saved, /version:\s*1/, "saved file must default version to 1");
+    // No bogus empty models block when no models were configured.
+    assert.doesNotMatch(saved, /^models:\s*$/m, "must not write empty models block");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

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

@@ -58,6 +58,7 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   verification_commands: ["npm test"],
   verification_auto_fix: true,
   verification_max_retries: 1,
+  per_unit_cost_cap_usd: 5,
   search_provider: "web",
   context_selection: "auto",
   widget_mode: "small",
@@ -86,6 +87,17 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   context_window_override: 128000,
   context_mode: { enabled: true },
   planning_depth: "deep",
+  claude_code_mcp: { per_model: { "claude-haiku": { allowed_servers: ["gsd-workflow"] } } },
+  workspace: {
+    mode: "parent",
+    repositories: {
+      frontend: {
+        path: "frontend",
+        role: "web UI",
+        verification: ["npm test"],
+      },
+    },
+  },
 };
 
 test("prefs wizard save path preserves every known preference key", async () => {
@@ -141,3 +153,70 @@ test("category summaries expose the wizard menu surface for configured prefs", (
   assert.match(summaries.integrations, /remote: C123/);
   assert.match(summaries.verification, /1 cmd/);
 });
+
+test("models wizard offers discovered models for enabled providers", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  const choices = [
+    "Models",
+    "local (2 models)",
+    "discovered-model",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+  ];
+  const ctx = {
+    // `getAllWithDiscovered` reads `this._all` so the wizard must call it as a
+    // method — invoking a detached reference would lose `this` and throw,
+    // mirroring the real ModelRegistry implementation.
+    modelRegistry: {
+      _all: [
+        { provider: "local", id: "baseline-model" },
+        { provider: "local", id: "discovered-model" },
+        { provider: "disabled", id: "hidden-model" },
+      ],
+      getAvailable() {
+        return [{ provider: "local", id: "baseline-model" }];
+      },
+      getAllWithDiscovered() {
+        return this._all;
+      },
+    },
+    ui: {
+      notify() {},
+      select: async (label: string, options: string[]) => {
+        const choice = choices.shift();
+        if (!choice && label === "GSD Preferences") return "── Save & Exit ──";
+        if (!choice && options.includes("(keep current)")) return "(keep current)";
+        if (!choice && options.includes("Done")) return "Done";
+        assert.ok(choice, `Unexpected prompt: ${label}`);
+        if (choice === "Models") {
+          const modelsOption = options.find((option) => option.startsWith("Models"));
+          assert.ok(modelsOption, "Expected Models category option");
+          return modelsOption;
+        }
+        assert.ok(options.includes(choice), `"${choice}" must be offered by "${label}"`);
+        assert.ok(!options.includes("hidden-model"), "models from disabled providers must not be offered");
+        return choice;
+      },
+      input: async () => null,
+    },
+    waitForIdle: async () => {},
+    reload: async () => {},
+  } as any;
+
+  try {
+    await handlePrefsWizard(ctx, "project", {}, { pathOverride: prefsPath });
+
+    assert.equal(choices.length, 0, "Expected all queued wizard choices to be consumed");
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.match(saved, /research:\s+local\/discovered-model/);
+    assert.doesNotMatch(saved, /hidden-model/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -17,7 +17,7 @@ import {
   getSlice,
 } from "../gsd-db.ts";
 import { autoHealSketchFlags } from "../state-reconciliation/drift/sketch-flag.ts";
-import { deriveStateFromDb } from "../state.ts";
+import { deriveState, deriveStateFromDb } from "../state.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";
 
@@ -198,6 +198,47 @@ test("ADR-011: autoHealSketchFlags flips is_sketch=0 when PLAN file exists", asy
   assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "post-heal: flag cleared");
 });
 
+test("ADR-011: deriveStateFromDb auto-heals stale sketch flag when PLAN exists", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedMilestoneWithSketchedS02(base);
+  writeS01Artifacts(base);
+  writePreferences(base, "phases:\n  skip_research: false");
+  // Simulate plan-slice completion where PLAN exists but is_sketch was not flipped.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-PLAN.md"),
+    "# S02 Plan\n",
+  );
+  process.chdir(base);
+
+  const state = await deriveStateFromDb(base);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "derive should clear stale is_sketch");
+  assert.equal(state.phase, "planning", "state should advance past refining once stale flag is healed");
+});
+
+test("ADR-011: deriveState uses canonical artifact root for sketch-flag healing", async (t) => {
+  const originalCwd = process.cwd();
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base, originalCwd));
+
+  seedMilestoneWithSketchedS02(base);
+  writeS01Artifacts(base);
+  writePreferences(base, "phases:\n  skip_research: false");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-PLAN.md"),
+    "# S02 Plan\n",
+  );
+  const worktreePath = join(base, "worker");
+  mkdirSync(worktreePath, { recursive: true });
+  process.chdir(worktreePath);
+
+  const state = await deriveState(worktreePath, { projectRootForReads: base });
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "deriveState should heal from canonical artifact root");
+  assert.equal(state.phase, "planning", "state should advance past refining when PLAN exists at canonical root");
+});
+
 test("ADR-011: schema v16 is idempotent — re-opening DB preserves is_sketch and sketch_scope columns", async (t) => {
   const originalCwd = process.cwd();
   const base = mkdtempSync(join(tmpdir(), "gsd-adr011-schema-"));

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

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt reports missing template variables with balanced braces", () => {
+  assert.throws(
+    () => loadPrompt("guided-discuss-milestone", {
+      milestoneId: "M001",
+      milestoneTitle: "Missing working directory",
+      structuredQuestionsAvailable: "false",
+      fastPathInstruction: "",
+      inlinedTemplates: "context template",
+      commitInstruction: "Do not commit during this test.",
+    }),
+    (error) => {
+      assert.ok(error instanceof Error);
+      assert.match(error.message, /template declares \{\{workingDirectory\}\} but no value was provided/);
+      assert.doesNotMatch(error.message, /\{\{workingDirectory\}\}\}/);
+      return true;
+    },
+  );
+});

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

@@ -10,7 +10,12 @@ import assert from "node:assert/strict";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
-import { MAX_TRANSIENT_AUTO_RESUMES, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import {
+  MAX_TRANSIENT_AUTO_RESUMES,
+  isTerminalDeletedWorktreeProviderError,
+  resetTransientRetryState,
+  shouldDeferTransientErrorToCoreRetry,
+} from "../bootstrap/agent-end-recovery.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -399,6 +404,25 @@ test("pauseAutoForProviderError falls back to indefinite pause when not rate lim
   ]);
 });
 
+test("isTerminalDeletedWorktreeProviderError matches removed auto-worktree paths only", () => {
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/.gsd/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/src/file.ts" does not exist'),
+    false,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" failed with EACCES'),
+    false,
+  );
+});
+
 // ── resumeAutoAfterProviderDelay ────────────────────────────────────────────
 
 test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded base path", async () => {
@@ -659,3 +683,15 @@ test("agent-session retryable error regex matches server_error (underscore)", ()
   // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
   assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });
+
+test("exhausted retry errors are not deferred back to core retry handling", () => {
+  const cls = classifyError("Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload");
+  assert.equal(cls.kind, "server");
+  assert.equal(
+    shouldDeferTransientErrorToCoreRetry(
+      cls,
+      "Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload",
+    ),
+    false,
+  );
+});

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Validates planning and task template quality-gate content.
+
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,11 +30,14 @@ 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");
+  assertTrue(plan.includes("node --test"), "plan.md instructs using node --test for verification");
 
   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");
+  assertTrue(taskPlan.includes("node --test"), "task-plan.md instructs using node --test for verification");
+  assertTrue(taskPlan.includes("node -e"), "task-plan.md mentions inline node -e as disallowed guidance");
 
   const sliceSummary = loadTemplate("slice-summary");
   assertTrue(sliceSummary.includes("## Operational Readiness"), "slice-summary.md contains ## Operational Readiness");

package/src/resources/extensions/gsd/tests/queue-reorder-ui.test.ts

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { showQueueReorder } from "../queue-reorder-ui.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+describe("queue-reorder-ui", () => {
+  test("keeps cursor visible while scrolling long queue with arrow keys (#4656)", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 20, configurable: true });
+
+    try {
+      const pending = Array.from({ length: 20 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+
+      let resolved: { order: string[]; depsToRemove: Array<{ milestone: string; dep: string }> } | null = null;
+      let lastRender: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, (value: any) => {
+              resolved = value;
+            });
+
+            for (let i = 0; i < 15; i++) component.handleInput("\u001b[B");
+            lastRender = component.render(100);
+            component.handleInput("\r");
+            return resolved;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, [], pending);
+
+      const joined = lastRender.join("\n");
+      assert.ok(joined.includes("M016"), "selected item should stay visible after scrolling");
+      assert.ok(lastRender.length <= 16, `overlay should fit terminal max-height, got ${lastRender.length}`);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/remediation-completion-guard.test.ts

@@ -1,6 +1,6 @@
 /**
- * Regression test for #2675: completing-milestone dispatch rule must
- * block completion when VALIDATION verdict is "needs-remediation".
+ * Regression tests for non-passing VALIDATION verdicts: completing-milestone
+ * dispatch must block completion when VALIDATION needs remediation or attention.
  *
  * Without this guard, needs-remediation + allSlicesDone causes a loop:
  * complete-milestone dispatched → agent refuses (correct) → no SUMMARY
@@ -66,6 +66,93 @@ test("completing-milestone blocks when VALIDATION verdict is needs-remediation (
   }
 });
 
+test("completing-milestone blocks when VALIDATION verdict is needs-attention (#5747)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-attention-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: needs-attention",
+        "remediation_round: 0",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Acceptance proof is incomplete and needs human attention.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes("needs-attention"),
+        "reason should mention needs-attention",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("completing-milestone blocks when VALIDATION verdict is fail (#5920)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-fail-verdict-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: fail",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Blocking failures remain unresolved.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes('verdict is "fail"'),
+        "reason should mention fail verdict",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("completing-milestone proceeds normally when VALIDATION verdict is pass (#2675 guard)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-remediation-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });