@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -4,8 +4,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
+import { registerToolCompatibility } from "@gsd/pi-coding-agent";
+
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
 import { buildMinimalAutoGsdToolSet, buildMinimalGsdToolSet, buildMinimalGsdWorkflowToolSet, buildRequestScopedGsdToolSet, MINIMAL_AUTO_BASE_TOOL_NAMES, MINIMAL_GSD_TOOL_NAMES, requestHasGsdCustomType, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "../bootstrap/register-hooks.ts";
+import { filterToolsForProvider } from "../model-router.ts";
 import { applyUnitSkillVisibility } from "../skill-scope.ts";
 
 test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surface", () => {
@@ -31,7 +34,7 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
   for (const toolName of MINIMAL_GSD_TOOL_NAMES) {
     assert.ok(result.includes(toolName), `expected ${toolName}`);
   }
-  assert.ok(!result.includes("gsd_plan_milestone"));
+  assert.ok(result.includes("gsd_plan_milestone"));
   assert.ok(!result.includes("gsd_task_complete"));
   assert.ok(!result.includes("gsd_graph"));
 });
@@ -98,22 +101,39 @@ test("buildMinimalAutoGsdToolSet keeps unit-specific completion tools without al
   assert.ok(!result.includes("gsd_complete_slice"));
 });
 
-test("buildMinimalAutoGsdToolSet re-resolves run-uat browser tools from the registry when dropped from the active set", () => {
-  // B2 drops the browser surface from the advertised interactive set, but the
-  // tools stay registered. run-uat must still get them: resolution reads the
-  // full registry, not just the (browser-stripped) active set.
-  const active = ["ask_user_questions", "bash", "read", "gsd_summary_save"];
+test("buildMinimalAutoGsdToolSet scopes run-uat to UAT-specific tools", () => {
+  const active = ["ask_user_questions", "bash", "read", "edit", "write", "gsd_summary_save"];
   const registered = [
     ...active,
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_journal_query",
+    "gsd_exec",
+    "gsd_save_gate_result",
+    "search-the-web",
     "browser_navigate",
     "browser_click",
     "browser_snapshot_refs",
-    "gsd_exec",
   ];
   const result = buildMinimalAutoGsdToolSet(active, "run-uat", registered);
+  assert.ok(result.includes("gsd_uat_exec"));
+  assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("gsd_resume"));
+  assert.ok(result.includes("gsd_milestone_status"));
+  assert.ok(result.includes("gsd_journal_query"));
   assert.ok(result.includes("browser_navigate"), "run-uat needs browser_navigate");
   assert.ok(result.includes("browser_click"), "run-uat needs browser_click");
-  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("ToolSearch"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("read"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("gsd_exec"));
+  assert.ok(!result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("gsd_save_gate_result"));
+  assert.ok(!result.includes("search-the-web"));
 });
 
 test("buildMinimalAutoGsdToolSet keeps only the auto base non-GSD tools", () => {
@@ -175,17 +195,27 @@ test("buildMinimalAutoGsdToolSet re-injects registered base tools filtered from
   assert.ok(result.includes("search-the-web"));
 });
 
-test("buildMinimalAutoGsdToolSet preserves browser tools for run-uat", () => {
+test("buildMinimalAutoGsdToolSet preserves compatible browser add-ons for run-uat", () => {
   const result = buildMinimalAutoGsdToolSet([
     "bash",
     "read",
+    "edit",
+    "write",
     "browser_navigate",
     "browser_click",
     "browser_type",
     "browser_assert",
     "browser_screenshot",
     "browser_wait_for",
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_journal_query",
+    "subagent",
     "gsd_summary_save",
+    "gsd_exec",
+    "gsd_save_gate_result",
     "gsd_task_complete",
     "memory_query",
     "capture_thought",
@@ -197,7 +227,17 @@ test("buildMinimalAutoGsdToolSet preserves browser tools for run-uat", () => {
   assert.ok(result.includes("browser_assert"));
   assert.ok(result.includes("browser_screenshot"));
   assert.ok(result.includes("browser_wait_for"));
-  assert.ok(result.includes("gsd_summary_save"));
+  assert.ok(result.includes("gsd_uat_exec"));
+  assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(!result.includes("ToolSearch"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("read"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("gsd_exec"));
+  assert.ok(!result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("gsd_save_gate_result"));
   assert.ok(!result.includes("gsd_task_complete"));
 });
 
@@ -218,6 +258,40 @@ test("buildMinimalAutoGsdToolSet prefers MCP browser tools for run-uat when avai
   assert.ok(!result.includes("browser_click"));
 });
 
+test("buildMinimalAutoGsdToolSet honors provider-compatible registered tools for run-uat", () => {
+  registerToolCompatibility("browser_screenshot", { producesImages: true });
+  const registered = [
+    "bash",
+    "read",
+    "ToolSearch",
+    "browser_navigate",
+    "browser_click",
+    "browser_screenshot",
+    "gsd_uat_exec",
+    "gsd_uat_result_save",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_journal_query",
+    "gsd_exec",
+    "gsd_summary_save",
+    "gsd_save_gate_result",
+  ];
+  const providerCompatible = filterToolsForProvider(registered, "openai-responses").compatible;
+  const result = buildMinimalAutoGsdToolSet(["gsd_uat_exec"], "run-uat", providerCompatible);
+
+  assert.ok(result.includes("gsd_uat_exec"));
+  assert.ok(result.includes("gsd_uat_result_save"));
+  assert.ok(result.includes("browser_navigate"));
+  assert.ok(result.includes("browser_click"));
+  assert.ok(!result.includes("browser_screenshot"), "provider-filtered screenshot tool must stay filtered");
+  assert.ok(!result.includes("ToolSearch"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("read"));
+  assert.ok(!result.includes("gsd_exec"));
+  assert.ok(!result.includes("gsd_summary_save"));
+  assert.ok(!result.includes("gsd_save_gate_result"));
+});
+
 test("buildMinimalAutoGsdToolSet includes discuss-slice persistence tools", () => {
   const result = buildMinimalAutoGsdToolSet([
     "bash",

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

@@ -39,6 +39,12 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_milestone_reopen", alias: "gsd_reopen_milestone" },
 ];
 
+const STANDALONE_TOOLS = [
+  "gsd_save_gate_result",
+  "gsd_skip_slice",
+  "gsd_uat_result_save",
+];
+
 // ─── Registration count ──────────────────────────────────────────────────────
 
 console.log('\n── Tool naming: registration count ──');
@@ -48,10 +54,14 @@ registerDbTools(pi);
 
 assert.deepStrictEqual(
   pi.tools.length,
-  RENAME_MAP.length * 2 + 2,
-  'Should register canonical/alias tool pairs plus 1 gate tool and 1 gsd_skip_slice',
+  RENAME_MAP.length * 2 + STANDALONE_TOOLS.length,
+  'Should register canonical/alias tool pairs plus standalone DB tools',
 );
 
+for (const name of STANDALONE_TOOLS) {
+  assert.ok(pi.tools.some((t: any) => t.name === name), `Standalone tool "${name}" should be registered`);
+}
+
 // ─── Both names exist for each pair ──────────────────────────────────────────
 
 console.log('\n── Tool naming: canonical and alias names exist ──');

package/src/resources/extensions/gsd/tests/tui-header-lifecycle.test.ts

@@ -7,12 +7,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { visibleWidth } from "@gsd/pi-tui";
 
-import { setCompletionProgressWidget, updateProgressWidget } from "../auto-dashboard.ts";
+import {
+  _resetWidgetModeForTests,
+  setCompletionProgressWidget,
+  setWidgetMode,
+  updateProgressWidget,
+} from "../auto-dashboard.ts";
 import type { GSDState } from "../types.ts";
 
 interface CapturedSetHeader {
@@ -143,10 +148,18 @@ test("updateProgressWidget gracefully no-ops when ctx.ui lacks setHeader/setStat
 
 // ── NEXT-mode footer guidance ───────────────────────────────────────────
 
-test("auto-dashboard widget render output includes /gsd next guidance when isStepMode is true", (t) => {
+test("auto-dashboard full widget render output includes /gsd next guidance when isStepMode is true", (t) => {
   const dir = makeTempDir("step-hint");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
-  t.after(() => cleanup(dir));
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+  _resetWidgetModeForTests();
+  setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+  t.after(() => {
+    _resetWidgetModeForTests();
+    cleanup(dir);
+  });
 
   let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
 
@@ -173,6 +186,7 @@ test("auto-dashboard widget render output includes /gsd next guidance when isSte
     bold: (text: string) => text,
   };
   const component = widgetFactory!(fakeTui, fakeTheme);
+  t.after(() => component.dispose?.());
   const lines = component.render(120);
 
   const hasStepHint = lines.some((line: string) => line.includes("/gsd next to advance one step"));
@@ -181,10 +195,18 @@ test("auto-dashboard widget render output includes /gsd next guidance when isSte
   if (component.dispose) component.dispose();
 });
 
-test("auto-dashboard widget render output omits /gsd next guidance when isStepMode is false", (t) => {
+test("auto-dashboard full widget render output omits /gsd next guidance when isStepMode is false", (t) => {
   const dir = makeTempDir("no-step-hint");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
-  t.after(() => cleanup(dir));
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+  _resetWidgetModeForTests();
+  setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+  t.after(() => {
+    _resetWidgetModeForTests();
+    cleanup(dir);
+  });
 
   let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
 
@@ -211,6 +233,7 @@ test("auto-dashboard widget render output omits /gsd next guidance when isStepMo
     bold: (text: string) => text,
   };
   const component = widgetFactory!(fakeTui, fakeTheme);
+  t.after(() => component.dispose?.());
   const lines = component.render(120);
 
   const hasStepHint = lines.some((line: string) => line.includes("/gsd next to advance one step"));

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -344,6 +344,7 @@ test("#5843: run-uat uses verification tools policy so build/test commands can r
   const manifest = UNIT_MANIFESTS["run-uat"];
 
   assert.strictEqual(manifest.tools.mode, "verification");
+  assert.deepEqual(manifest.tools.allowedSubagents, ["mnemo", "scout", "reviewer", "tester"]);
 
   const buildResult = shouldBlockPlanningUnit(
     "bash",
@@ -367,6 +368,20 @@ test("#5843: run-uat uses verification tools policy so build/test commands can r
   );
   assert.strictEqual(sourceWriteResult.block, true);
   assert.match(sourceWriteResult.reason!, /tools-policy "verification"/);
+
+  const subagentResult = shouldBlockPlanningUnit(
+    "subagent",
+    "",
+    process.cwd(),
+    "run-uat",
+    manifest.tools,
+    ["mnemo"],
+  );
+  assert.strictEqual(
+    subagentResult.block,
+    false,
+    `run-uat must allow listed verification subagents: ${subagentResult.reason}`,
+  );
 });
 
 test("planning-dispatch hard block message omits internal tracker references", () => {
@@ -420,6 +435,11 @@ test('Unit Tool Contract exposes subagent dispatch permissions', () => {
     allowedSubagents: ["reviewer", "security", "tester"],
     toolsMode: "planning-dispatch",
   });
+  assert.deepEqual(resolveSubagentPermissionContract("run-uat"), {
+    allowed: true,
+    allowedSubagents: ["mnemo", "scout", "reviewer", "tester"],
+    toolsMode: "verification",
+  });
   assert.deepEqual(resolveSubagentPermissionContract("discuss-milestone"), {
     allowed: false,
     allowedSubagents: [],
@@ -427,21 +447,24 @@ test('Unit Tool Contract exposes subagent dispatch permissions', () => {
   });
 });
 
-test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
+test('dispatch-capable manifests declare globally allowed subagents', () => {
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
-    if (manifest.tools.mode !== "planning-dispatch") continue;
+    const allowedSubagents = "allowedSubagents" in manifest.tools
+      ? manifest.tools.allowedSubagents
+      : undefined;
+    if (!allowedSubagents) continue;
     assert.ok(
-      Array.isArray(manifest.tools.allowedSubagents) && manifest.tools.allowedSubagents.length > 0,
-      `manifest "${unitType}" has planning-dispatch policy but no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
+      Array.isArray(allowedSubagents) && allowedSubagents.length > 0,
+      `manifest "${unitType}" enables subagent dispatch but has no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
     );
-    for (const agent of manifest.tools.allowedSubagents) {
+    for (const agent of allowedSubagents) {
       assert.ok(
         typeof agent === "string" && agent.length > 0,
         `manifest "${unitType}" has empty/invalid allowedSubagents entry: ${JSON.stringify(agent)}`,
       );
       assert.ok(
         ALLOWED_PLANNING_DISPATCH_AGENTS.has(agent),
-        `manifest "${unitType}" allows "${agent}", but the runtime planning-dispatch registry will hard-block it`,
+        `manifest "${unitType}" allows "${agent}", but the runtime controlled-dispatch registry will hard-block it`,
       );
     }
   }

package/src/resources/extensions/gsd/tests/validation-block-guard.test.ts

@@ -54,6 +54,8 @@ test("validation block allows recovery, diagnostics, and unrelated commands", ()
     "status",
     "verdict pass --rationale ok",
     "validate-milestone",
+    "dispatch reassess",
+    "dispatch reassess-roadmap",
     "dispatch validate",
     "dispatch validate-milestone",
     "park M006",
@@ -122,3 +124,22 @@ test("validation block message includes attempted command and recovery options",
   assert.match(message, /\/gsd verdict pass --rationale/);
   assert.match(message, /\/gsd park M006/);
 });
+
+test("validation block message can guide remediation through dispatch reassess", () => {
+  const message = formatValidationBlockedMessage({
+    ...blockedState(),
+    blockers: [
+      [
+        "Milestone M006 is blocked because milestone validation returned needs-remediation, but all slices are complete.",
+        "Fix options:",
+        "1. Run `/gsd dispatch reassess` to add remediation slices, then run `/gsd auto`",
+        "2. If the finding is acceptable, override it: `/gsd verdict pass --rationale \"why this is okay\"`",
+        "3. If this should wait, defer it explicitly: `/gsd park M006`",
+      ].join("\n"),
+    ],
+  }, "auto");
+
+  assert.ok(message);
+  assert.match(message, /\/gsd dispatch reassess/);
+  assert.doesNotMatch(message, /gsd_reassess_roadmap/);
+});

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -19,6 +19,14 @@ test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport"
   assert.equal(result, true);
 });
 
+test("shouldAutoPrepareWorkflowMcp enables prep when Claude Code provider is known before auth mode settles", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+  });
+
+  assert.equal(result, true);
+});
+
 test("prepareWorkflowMcpForProject uses the selected unit model when session provider differs", (t) => {
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-unit-model-"));
   const notifications: Array<{ message: string; level: "info" | "warning" | "error" | "success" }> = [];
@@ -46,7 +54,7 @@ test("prepareWorkflowMcpForProject uses the selected unit model when session pro
 
   assert.equal(result?.status, "created");
   assert.equal(existsSync(join(projectRoot, ".mcp.json")), true);
-  assert.match(notifications.map((entry) => entry.message).join("\n"), /Claude Code MCP prepared/);
+  assert.match(notifications.map((entry) => entry.message).join("\n"), /GSD MCP Server Prepared/);
 });
 
 test("shouldAutoPrepareWorkflowMcp stays disabled for non-Claude active provider even when claude-code is ready", () => {
@@ -163,7 +171,14 @@ test("before_agent_start auto-prepares project workflow MCP for Claude Code CLI"
   };
   assert.ok(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME]);
   assert.ok(parsed.mcpServers?.[GSD_BROWSER_MCP_SERVER_NAME]);
-  assert.match(notifications.join("\n"), /Claude Code MCP prepared/);
+  const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {
+    enabledMcpjsonServers?: string[];
+  };
+  assert.deepEqual(settings.enabledMcpjsonServers, [
+    GSD_WORKFLOW_MCP_SERVER_NAME,
+    GSD_BROWSER_MCP_SERVER_NAME,
+  ]);
+  assert.match(notifications.join("\n"), /GSD MCP Server Prepared/);
 });
 
 test("before_agent_start returns discovered skill fallback without project .gsd", async (t) => {

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -30,6 +30,7 @@ import {
   executeSliceComplete,
   executeSliceReopen,
   executeValidateMilestone,
+  executeUatResultSave,
 } from "../tools/workflow-tool-executors.ts";
 
 function makeTmpBase(): string {
@@ -504,6 +505,88 @@ test("executePlanSlice marks validation failures with isError", async () => {
   }
 });
 
+test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone worktree", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const worktreeExecDir = join(worktree, ".gsd", "exec");
+  const browserTimelineDir = join(base, ".artifacts", "browser", "session");
+  const evidenceId = "worktree-uat-evidence";
+  const browserTimelinePath = join(browserTimelineDir, "s02-uat-browser-timeline.json");
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Milestone One");
+    seedSlice("M001", "S02", "complete");
+    mkdirSync(worktreeExecDir, { recursive: true });
+    mkdirSync(browserTimelineDir, { recursive: true });
+    writeFileSync(browserTimelinePath, JSON.stringify({ summary: "browser timeline evidence" }), "utf-8");
+    writeFileSync(
+      join(worktreeExecDir, `${evidenceId}.meta.json`),
+      JSON.stringify({
+        id: evidenceId,
+        metadata: {
+          kind: "uat_exec",
+          milestoneId: "M001",
+          sliceId: "S02",
+          checkId: "UAT-01",
+          intent: "uat-runtime-check",
+        },
+      }),
+      "utf-8",
+    );
+
+    const result = await inProjectDir(worktree, () => executeUatResultSave({
+      milestoneId: "M001",
+      sliceId: "S02",
+      uatType: "runtime-executable",
+      verdict: "PASS",
+      checks: [{
+        id: "UAT-01",
+        description: "Runtime path C:\\tmp|uat evidence was captured in the active worktree",
+        mode: "runtime",
+        result: "PASS",
+        evidence: [
+          { kind: "gsd_uat_exec", ref: evidenceId },
+          { kind: "browser", ref: browserTimelinePath },
+        ],
+        notes: "Worktree-local gsd_uat_exec metadata should resolve with backslash \\ and pipe |.",
+      }],
+      presentation: {
+        surface: "mcp",
+        presentedTools: [
+          "gsd_uat_exec",
+          "gsd_uat_result_save",
+          "gsd_resume",
+          "gsd_milestone_status",
+          "gsd_journal_query",
+        ],
+        blockedTools: [
+          { name: "gsd_exec", reason: "forbidden during run-uat" },
+          { name: "gsd_summary_save", reason: "forbidden during run-uat" },
+          { name: "gsd_save_gate_result", reason: "forbidden during run-uat" },
+        ],
+      },
+      notes: "UAT passed with worktree-local evidence.",
+    }, worktree));
+
+    assert.equal(result.isError, undefined);
+    assert.equal(result.details.operation, "save_uat_result");
+    assert.equal(result.details.verdict, "PASS");
+    assert.ok(
+      existsSync(join(base, ".gsd", "uat", "M001", "S02", "attempt-1.json")),
+      "attempt JSON should be persisted under the authoritative project .gsd",
+    );
+    const assessment = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-ASSESSMENT.md"),
+      "utf-8",
+    );
+    assert.match(assessment, /Runtime path C:\\\\tmp\\\|uat evidence/);
+    assert.match(assessment, /backslash \\\\ and pipe \\\|/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSliceComplete coerces string enrichment entries and writes summary/UAT artifacts", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -27,6 +27,10 @@ const PLANNING_DISPATCH_REVIEW: ToolsPolicy = {
 const READ_ONLY: ToolsPolicy = { mode: 'read-only' };
 const ALL: ToolsPolicy = { mode: 'all' };
 const VERIFICATION: ToolsPolicy = { mode: 'verification' };
+const VERIFICATION_UAT: ToolsPolicy = {
+  mode: 'verification',
+  allowedSubagents: ['mnemo', 'scout', 'reviewer', 'tester'],
+};
 const DOCS: ToolsPolicy = {
   mode: 'docs',
   allowedPathGlobs: ['docs/**', 'README.md', 'README.*.md', 'CHANGELOG.md', '*.md'],
@@ -469,6 +473,27 @@ test('verification-mode: run-uat still blocks subagent dispatch', () => {
   assert.match(r.reason!, /subagent dispatch is not permitted/);
 });
 
+test('verification-mode: run-uat allows explicit UAT specialist subagents', () => {
+  for (const agent of ['mnemo', 'scout', 'reviewer', 'tester']) {
+    const r = shouldBlockPlanningUnit('subagent', '', BASE, 'run-uat', VERIFICATION_UAT, [agent]);
+    assert.strictEqual(r.block, false, `expected ${agent} to be allowed: ${r.reason}`);
+  }
+});
+
+test('verification-mode: run-uat blocks implementation-tier subagents', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'run-uat', VERIFICATION_UAT, ['worker']);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /"worker"/);
+  assert.match(r.reason!, /read-only specialists/);
+});
+
+test('verification-mode: run-uat blocks read-only specialists not listed by policy', () => {
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'run-uat', VERIFICATION_UAT, ['security']);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /"security"/);
+  assert.match(r.reason!, /ToolsPolicy\.allowedSubagents|permitted agents for this unit/);
+});
+
 // ─── read-only mode ───────────────────────────────────────────────────────
 
 test('read-only: blocks any edit even to .gsd/', () => {