@opengsd/gsd-pi 1.2.0-dev.955e4da0 → 1.2.0-dev.d6c5343c

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

@@ -0,0 +1,209 @@
+// gsd-pi — ADR-032 Unit Closeout module tests (Interactive Closeout adapter path).
+//
+// All git/preference/notification effects go through the injected deps seam —
+// no real repos, no notification store state.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  closeUnit,
+  isUnitCloseoutTool,
+  runInteractiveUnitCloseout,
+  type UnitCloseoutDeps,
+} from "../unit-closeout.ts";
+
+interface DepsLog {
+  commits: Array<{ unitType: string; unitId: string }>;
+  notices: Array<{ message: string; severity: string }>;
+}
+
+function makeDeps(overrides: {
+  isolation?: "none" | "worktree" | "branch";
+  branch?: string | null;
+  commitResult?: string | null | (() => string | null);
+} = {}): { deps: UnitCloseoutDeps; log: DepsLog } {
+  const log: DepsLog = { commits: [], notices: [] };
+  const deps: UnitCloseoutDeps = {
+    isolationMode: () => overrides.isolation ?? "none",
+    currentBranch: () => (overrides.branch === undefined ? "main" : overrides.branch),
+    commit: (_basePath, unitType, unitId) => {
+      log.commits.push({ unitType, unitId });
+      const result = overrides.commitResult;
+      if (typeof result === "function") return result();
+      return result === undefined ? "chore(gsd): closeout" : result;
+    },
+    notify: (message, severity) => {
+      log.notices.push({ message, severity });
+    },
+  };
+  return { deps, log };
+}
+
+const BASE = "/tmp/closeout-test-project";
+
+test("task boundary commits and stays quiet", () => {
+  const { deps, log } = makeDeps({ isolation: "worktree" });
+  const result = closeUnit(
+    { basePath: BASE, unitType: "execute-task", unitId: "M001/S01/T01", boundary: "task", outcome: "complete" },
+    deps,
+  );
+  assert.equal(result.gitVerdict, "committed");
+  assert.equal(result.notice, undefined);
+  assert.deepEqual(log.commits, [{ unitType: "execute-task", unitId: "M001/S01/T01" }]);
+  assert.equal(log.notices.length, 0);
+});
+
+test("milestone boundary under isolation none commits without a notice", () => {
+  const { deps, log } = makeDeps({ isolation: "none" });
+  const result = closeUnit(
+    { basePath: BASE, unitType: "complete-milestone", unitId: "M001", boundary: "milestone", outcome: "complete" },
+    deps,
+  );
+  assert.equal(result.gitVerdict, "committed");
+  assert.equal(log.notices.length, 0);
+});
+
+test("milestone boundary off-worktree under isolation worktree fails closed loudly", () => {
+  const { deps, log } = makeDeps({ isolation: "worktree", branch: "main" });
+  const result = closeUnit(
+    { basePath: BASE, unitType: "complete-milestone", unitId: "M001", boundary: "milestone", outcome: "complete" },
+    deps,
+  );
+  assert.equal(result.gitVerdict, "isolation-bypassed");
+  assert.equal(log.notices.length, 1);
+  assert.equal(log.notices[0].severity, "warning");
+  assert.match(log.notices[0].message, /isolation preference was not honoured/);
+  assert.match(log.notices[0].message, /git\.isolation is "worktree"/);
+  assert.match(log.notices[0].message, /committed directly on "main"/);
+});
+
+test("milestone boundary on a milestone branch defers the merge to worktree tooling", () => {
+  const { deps, log } = makeDeps({ isolation: "worktree", branch: "milestone/M001" });
+  const result = closeUnit(
+    { basePath: BASE, unitType: "complete-milestone", unitId: "M001", boundary: "milestone", outcome: "complete" },
+    deps,
+  );
+  assert.equal(result.gitVerdict, "milestone-branch");
+  assert.equal(log.notices.length, 1);
+  assert.equal(log.notices[0].severity, "info");
+  assert.match(log.notices[0].message, /worktree merge/);
+});
+
+test("clean tree records nothing-to-commit, and the bypass notice says so", () => {
+  const { deps, log } = makeDeps({ isolation: "branch", branch: "main", commitResult: null });
+  const result = closeUnit(
+    { basePath: BASE, unitType: "complete-milestone", unitId: "M001", boundary: "milestone", outcome: "complete" },
+    deps,
+  );
+  assert.equal(result.gitVerdict, "isolation-bypassed");
+  assert.equal(result.commitMessage, null);
+  assert.match(log.notices[0].message, /nothing left to commit/);
+});
+
+test("commit failure is surfaced, never thrown", () => {
+  const { deps, log } = makeDeps({
+    commitResult: () => {
+      throw new Error("index.lock exists");
+    },
+  });
+  const result = closeUnit(
+    { basePath: BASE, unitType: "complete-milestone", unitId: "M001", boundary: "milestone", outcome: "complete" },
+    deps,
+  );
+  assert.equal(result.gitVerdict, "commit-failed");
+  assert.equal(log.notices[0].severity, "error");
+  assert.match(log.notices[0].message, /index\.lock/);
+});
+
+test("re-entrancy is safe: a re-fire over an already-clean tree is nothing-to-commit", () => {
+  // No result cache — re-entrancy is absorbed by git itself. The second fire
+  // sees a clean tree (commit returns null) and records nothing-to-commit.
+  let firstFire = true;
+  const { deps, log } = makeDeps({
+    isolation: "worktree",
+    branch: "main",
+    commitResult: () => {
+      const committed = firstFire;
+      firstFire = false;
+      return committed ? "chore(gsd): closeout" : null;
+    },
+  });
+  const request = {
+    basePath: BASE,
+    unitType: "complete-milestone",
+    unitId: "M001",
+    boundary: "milestone" as const,
+    outcome: "complete" as const,
+  };
+  const first = closeUnit(request, deps);
+  const second = closeUnit(request, deps);
+  assert.equal(first.gitVerdict, "isolation-bypassed");
+  assert.equal(first.commitMessage, "chore(gsd): closeout");
+  assert.equal(second.gitVerdict, "isolation-bypassed");
+  assert.equal(second.commitMessage, null);
+  assert.match(second.notice ?? "", /nothing left to commit/);
+  assert.equal(log.commits.length, 2);
+});
+
+// ─── Interactive adapter mapping ──────────────────────────────────────────
+
+test("isUnitCloseoutTool recognizes exactly the closeout tools", () => {
+  assert.equal(isUnitCloseoutTool("gsd_complete_milestone"), true);
+  assert.equal(isUnitCloseoutTool("gsd_save_gate_result"), false);
+  assert.equal(isUnitCloseoutTool("read"), false);
+});
+
+test("interactive adapter is scoped to milestone boundaries — task/slice tools do not commit", () => {
+  const { deps, log } = makeDeps();
+  assert.equal(isUnitCloseoutTool("gsd_task_complete"), false);
+  assert.equal(isUnitCloseoutTool("gsd_slice_complete"), false);
+  assert.equal(
+    runInteractiveUnitCloseout(
+      { basePath: BASE, canonicalToolName: "gsd_task_complete", input: { milestoneId: "M001", sliceId: "S02", taskId: "T03" } },
+      deps,
+    ),
+    null,
+  );
+  assert.equal(
+    runInteractiveUnitCloseout(
+      { basePath: BASE, canonicalToolName: "gsd_slice_complete", input: { milestoneId: "M001", sliceId: "S02" } },
+      deps,
+    ),
+    null,
+  );
+  assert.equal(log.commits.length, 0);
+});
+
+test("interactive adapter maps milestone tool input to canonical unit type", () => {
+  const { deps, log } = makeDeps();
+  const result = runInteractiveUnitCloseout(
+    { basePath: BASE, canonicalToolName: "gsd_complete_milestone", input: { milestoneId: "M001" } },
+    deps,
+  );
+  assert.equal(result?.gitVerdict, "committed");
+  assert.deepEqual(log.commits, [{ unitType: "complete-milestone", unitId: "M001" }]);
+});
+
+test("interactive adapter accepts snake_case ids and milestone-only input", () => {
+  const { deps, log } = makeDeps();
+  const result = runInteractiveUnitCloseout(
+    { basePath: BASE, canonicalToolName: "gsd_complete_milestone", input: { milestone_id: "M007" } },
+    deps,
+  );
+  assert.equal(result?.gitVerdict, "committed");
+  assert.deepEqual(log.commits, [{ unitType: "complete-milestone", unitId: "M007" }]);
+});
+
+test("interactive adapter declines unidentifiable input instead of guessing", () => {
+  const { deps, log } = makeDeps();
+  assert.equal(
+    runInteractiveUnitCloseout({ basePath: BASE, canonicalToolName: "gsd_complete_milestone", input: {} }, deps),
+    null,
+  );
+  assert.equal(
+    runInteractiveUnitCloseout({ basePath: BASE, canonicalToolName: "not_a_closeout_tool", input: { milestoneId: "M001" } }, deps),
+    null,
+  );
+  assert.equal(log.commits.length, 0);
+});

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

@@ -11,6 +11,7 @@ import {
   composeContractedUnitContext,
   composeContextModeInstructions,
   composeInlinedContext,
+  composeToolSurfaceInstructions,
   composeUnitContext,
   manifestBudgetChars,
   type ArtifactResolver,
@@ -24,6 +25,7 @@ import type {
   UnitContextManifest,
 } from "../unit-context-manifest.ts";
 import { KNOWN_UNIT_TYPES, UNIT_MANIFESTS } from "../unit-context-manifest.ts";
+import { getUnitToolSurfaceContract } from "../unit-tool-contracts.ts";
 import {
   buildExecuteTaskPrompt,
   buildGateEvaluatePrompt,
@@ -165,12 +167,32 @@ test("Context Mode composer: every known eligible unit renders its configured la
     }
     assert.ok(out.startsWith("## Context Mode"), `${unitType} should render standalone Context Mode heading`);
     assert.match(out, new RegExp(`Lane: \\*\\*${laneLabelByMode[manifest.contextMode]} lane\\*\\*\\.`, "i"));
-    assert.match(out, /`gsd_exec`/, `${unitType} should mention gsd_exec`);
-    assert.match(out, /`gsd_exec_search`/, `${unitType} should mention gsd_exec_search`);
+    const forbidden = getUnitToolSurfaceContract(unitType)?.forbiddenGsdTools ?? {};
+    if ("gsd_exec" in forbidden) {
+      // Units that forbid gsd_exec (run-uat) have it stripped from their
+      // Claude Code dispatch surface; guidance steering to it produces
+      // "No such tool available" loops in the dispatched agent.
+      assert.doesNotMatch(out, /`gsd_exec`/, `${unitType} forbids gsd_exec; guidance must not steer to it`);
+      assert.doesNotMatch(out, /`gsd_exec_search`/, `${unitType} guidance must not steer to gsd_exec_search`);
+      assert.match(out, /`gsd_uat_exec`/, `${unitType} guidance should steer to gsd_uat_exec instead`);
+    } else {
+      assert.match(out, /`gsd_exec`/, `${unitType} should mention gsd_exec`);
+      assert.match(out, /`gsd_exec_search`/, `${unitType} should mention gsd_exec_search`);
+    }
     assert.match(out, /`gsd_resume`/, `${unitType} should mention gsd_resume`);
   }
 });
 
+test("Context Mode composer: run-uat guidance steers to gsd_uat_exec in both render modes", () => {
+  const nested = composeContextModeInstructions("run-uat", { enabled: true, renderMode: "nested" });
+  assert.match(nested, /^Context Mode \(verification lane\): /);
+  assert.match(nested, /`gsd_uat_exec`/);
+  assert.doesNotMatch(nested, /`gsd_exec`/);
+  const standalone = composeContextModeInstructions("run-uat", { enabled: true, renderMode: "standalone" });
+  assert.match(standalone, /`gsd_uat_exec`/);
+  assert.doesNotMatch(standalone, /`gsd_exec`/);
+});
+
 test("Context Mode composer: workflow-preferences and research-decision render no Context Mode block", () => {
   assert.strictEqual(
     composeContextModeInstructions("workflow-preferences", { enabled: true, renderMode: "standalone" }),
@@ -182,6 +204,49 @@ test("Context Mode composer: workflow-preferences and research-decision render n
   );
 });
 
+test("Tool Surface composer: run-uat forbids gsd_exec and Bash", () => {
+  const out = composeToolSurfaceInstructions("run-uat", { renderMode: "standalone" });
+  assert.match(out, /^## Tool Surface/);
+  assert.match(out, /Do not call `gsd_exec`/);
+  assert.match(out, /`Bash`/);
+  assert.match(out, /`gsd_uat_exec`/);
+  assert.match(out, /`gsd_save_gate_result`/);
+  assert.match(out, /`gsd_summary_save`/);
+});
+
+test("Tool Surface composer: complete-slice steers verification to gsd_exec", () => {
+  const out = composeToolSurfaceInstructions("complete-slice", { renderMode: "standalone" });
+  assert.match(out, /`gsd_exec`/);
+  assert.match(out, /not direct `bash`/);
+  assert.match(out, /`gsd_uat_result_save`/);
+});
+
+test("Tool Surface composer: planning units restrict writes to .gsd", () => {
+  const out = composeToolSurfaceInstructions("discuss-milestone", { renderMode: "standalone" });
+  assert.match(out, /restricted to `\.gsd\/\*\*`/);
+  assert.match(out, /`ask_user_questions`/);
+});
+
+test("Tool Surface composer: planning-dispatch lists allowed subagents", () => {
+  const out = composeToolSurfaceInstructions("plan-slice", { renderMode: "standalone" });
+  assert.match(out, /\*\*scout\*\*/);
+  assert.match(out, /\*\*planner\*\*/);
+});
+
+test("Tool Surface composer: execute-task warns against slice/milestone closeout tools", () => {
+  const out = composeToolSurfaceInstructions("execute-task", { renderMode: "nested" });
+  assert.match(out, /^Tool surface: /);
+  assert.match(out, /`gsd_task_complete`/);
+  assert.match(out, /Do not call `gsd_slice_complete`/);
+});
+
+test("Tool Surface composer: unknown unit renders empty block", () => {
+  assert.strictEqual(
+    composeToolSurfaceInstructions("never-dispatched", { renderMode: "standalone" }),
+    "",
+  );
+});
+
 // ─── Integration: migrated buildReassessRoadmapPrompt ─────────────────────
 
 function makeFixtureBase(): string {

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

@@ -0,0 +1,163 @@
+// gsd-pi — ADR-033 Unit Registry parity guard.
+//
+// Pins every view derived from UNIT_REGISTRY to the exact values the
+// hand-maintained tables held before the registry existed. A failure here
+// means a registry edit changed a derived surface — intended changes update
+// the pinned expectation in the same diff.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  KNOWN_UNIT_TYPES,
+  UNIT_REGISTRY,
+  EXECUTE_TASK_UNIT_TYPES,
+  SECTION_CLOSE_GATE_UNIT_TYPES,
+  getUnitDescriptor,
+  getUnitPhaseChain,
+} from "../unit-registry.ts";
+import {
+  AUTO_UNIT_SCOPED_TOOLS,
+  UNIT_TOOL_CONTRACTS,
+  getUnitToolSurfaceContract,
+} from "../unit-tool-contracts.ts";
+import { UNIT_MANIFESTS } from "../unit-context-manifest.ts";
+import { phaseChainForUnit } from "../preferences-models.ts";
+
+// ─── Pinned pre-registry values ───────────────────────────────────────────
+
+const EXPECTED_KNOWN_UNIT_TYPES = [
+  "research-milestone",
+  "plan-milestone",
+  "discuss-milestone",
+  "validate-milestone",
+  "complete-milestone",
+  "research-slice",
+  "plan-slice",
+  "refine-slice",
+  "replan-slice",
+  "complete-slice",
+  "reassess-roadmap",
+  "execute-task",
+  "reactive-execute",
+  "run-uat",
+  "gate-evaluate",
+  "rewrite-docs",
+  "triage-captures",
+  "quick-task",
+  "workflow-preferences",
+  "discuss-project",
+  "discuss-requirements",
+  "research-decision",
+  "research-project",
+];
+
+// The contract table carried two keys KNOWN_UNIT_TYPES never had (variants)
+// and lacked two it did have (sidecars without contracts).
+const EXPECTED_CONTRACT_ONLY_TYPES = ["discuss-slice", "execute-task-simple"];
+const EXPECTED_CONTRACT_LESS_TYPES = ["triage-captures", "quick-task"];
+
+const EXPECTED_EXECUTE_TASK_SET = ["execute-task", "execute-task-simple", "reactive-execute"];
+const EXPECTED_SECTION_CLOSE_SET = [
+  ...EXPECTED_EXECUTE_TASK_SET,
+  "complete-slice",
+  "validate-milestone",
+];
+
+const EXPECTED_PHASE_CHAINS: Record<string, string[] | undefined> = {
+  "research-milestone": ["research"],
+  "research-slice": ["research"],
+  "research-project": ["research"],
+  "plan-milestone": ["planning"],
+  "plan-slice": ["planning"],
+  "refine-slice": ["planning"],
+  "replan-slice": ["planning"],
+  "discuss-milestone": ["discuss", "planning"],
+  "discuss-slice": ["discuss", "planning"],
+  "discuss-project": ["discuss", "planning"],
+  "discuss-requirements": ["discuss", "planning"],
+  "workflow-preferences": ["discuss", "planning"],
+  "research-decision": ["discuss", "planning"],
+  "execute-task": ["execution"],
+  "reactive-execute": ["execution"],
+  "execute-task-simple": ["execution_simple", "execution"],
+  "complete-slice": ["completion"],
+  "complete-milestone": ["completion"],
+  "worktree-merge": ["completion"],
+  "run-uat": ["uat", "completion"],
+  "reassess-roadmap": ["validation", "planning"],
+  "rewrite-docs": ["validation", "planning"],
+  "gate-evaluate": ["validation", "planning"],
+  "validate-milestone": ["validation", "planning"],
+  "triage-captures": undefined,
+  "quick-task": undefined,
+  subagent: ["subagent"],
+  "subagent/scout": ["subagent"],
+  "no-such-unit": undefined,
+};
+
+// ─── Derived-view parity ──────────────────────────────────────────────────
+
+test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
+  assert.deepEqual([...KNOWN_UNIT_TYPES], EXPECTED_KNOWN_UNIT_TYPES);
+});
+
+test("UNIT_TOOL_CONTRACTS keeps the pre-registry key set, asymmetries included", () => {
+  const contractKeys = Object.keys(UNIT_TOOL_CONTRACTS);
+  for (const variant of EXPECTED_CONTRACT_ONLY_TYPES) {
+    assert.ok(contractKeys.includes(variant), `variant ${variant} must keep its contract`);
+    assert.ok(!KNOWN_UNIT_TYPES.includes(variant as never), `${variant} must stay out of KNOWN_UNIT_TYPES`);
+  }
+  for (const sidecar of EXPECTED_CONTRACT_LESS_TYPES) {
+    assert.ok(!contractKeys.includes(sidecar), `${sidecar} must stay contract-less`);
+    assert.equal(getUnitToolSurfaceContract(sidecar), undefined);
+  }
+  const expectedKeys = [
+    ...EXPECTED_KNOWN_UNIT_TYPES.filter((t) => !EXPECTED_CONTRACT_LESS_TYPES.includes(t)),
+    ...EXPECTED_CONTRACT_ONLY_TYPES,
+  ].sort();
+  assert.deepEqual([...contractKeys].sort(), expectedKeys);
+});
+
+test("scope-class Sets match the pre-registry hand-maintained Sets", () => {
+  assert.deepEqual([...EXECUTE_TASK_UNIT_TYPES].sort(), [...EXPECTED_EXECUTE_TASK_SET].sort());
+  assert.deepEqual([...SECTION_CLOSE_GATE_UNIT_TYPES].sort(), [...EXPECTED_SECTION_CLOSE_SET].sort());
+});
+
+test("phaseChainForUnit matches the pre-registry switch for every known input", () => {
+  for (const [unitType, expected] of Object.entries(EXPECTED_PHASE_CHAINS)) {
+    assert.deepEqual(
+      phaseChainForUnit(unitType),
+      expected,
+      `phase chain for ${unitType}`,
+    );
+  }
+});
+
+test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
+  for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
+    assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);
+  }
+  assert.deepEqual(
+    Object.keys(AUTO_UNIT_SCOPED_TOOLS).sort(),
+    Object.keys(UNIT_TOOL_CONTRACTS).sort(),
+  );
+});
+
+// ─── Registry-internal coherence ──────────────────────────────────────────
+
+test("every primary unit type has a manifest; manifests cover nothing else", () => {
+  const manifestKeys = Object.keys(UNIT_MANIFESTS).sort();
+  assert.deepEqual(manifestKeys, [...KNOWN_UNIT_TYPES].sort());
+});
+
+test("every registry row is reachable through the descriptor accessor", () => {
+  for (const unitType of Object.keys(UNIT_REGISTRY)) {
+    const descriptor = getUnitDescriptor(unitType);
+    assert.ok(descriptor, `descriptor for ${unitType}`);
+    assert.ok(["primary", "variant"].includes(descriptor.kind));
+    assert.ok(["execute-task", "section-close", "standard"].includes(descriptor.scopeClass));
+    assert.equal(getUnitPhaseChain(unitType), descriptor.phaseChain);
+  }
+  assert.equal(getUnitDescriptor("no-such-unit"), undefined);
+});

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

@@ -15,6 +15,10 @@ function scaffoldProject(root: string, pkg: Record<string, unknown>): void {
   writeFileSync(join(root, "package.json"), JSON.stringify(pkg, null, 2));
 }
 
+const LEGACY_ENGINE = { engine: "legacy", source: "probe", reason: "test" } as const;
+const MANAGED_ENGINE = { engine: "gsd-browser", source: "probe", reason: "test" } as const;
+const OFF_ENGINE = { engine: "off", source: "env", reason: "test" } as const;
+
 describe("web-app-uat guidance", () => {
   test("returns null for non-web projects", () => {
     const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
@@ -36,15 +40,54 @@ describe("web-app-uat guidance", () => {
         scripts: { dev: "vite" },
       });
       assert.equal(detectWebApp(root), true);
-      const block = buildWebAppUatGuidanceBlock(root);
+      const block = buildWebAppUatGuidanceBlock(root, LEGACY_ENGINE);
       assert.ok(block);
       assert.match(block!, /browser-executable/);
+      assert.match(block!, /Playwright-backed `browser_\*` tools/);
       assert.match(block!, /Playwright scaffolding/);
     } finally {
       rmSync(root, { recursive: true, force: true });
     }
   });
 
+  test("describes the managed gsd-browser engine when it is the resolved backing", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, MANAGED_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /managed gsd-browser engine/);
+      assert.match(block!, /browser-executable/);
+      assert.doesNotMatch(block!, /Playwright-backed/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("steers to runtime-executable UAT when browser tools are off", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, OFF_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /browser tools are disabled/);
+      assert.doesNotMatch(block!, /- `browser-executable`/);
+      // mixed/live-runtime require browser tools per UAT_MODE_POLICIES, so the
+      // bullet must drop out too — recommending them would dead-end at dispatch.
+      assert.doesNotMatch(block!, /- `mixed`/);
+      assert.doesNotMatch(block!, /interactive `browser_\*` checks/);
+      assert.match(block!, /runtime-executable/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   test("detects existing Playwright and npm script", () => {
     const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
     try {

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

@@ -495,8 +495,8 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
               estimate: "10m",
               files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
               verify: "node --test",
-              inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
-              expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
+              inputs: [],
+              expectedOutput: ["src/bridge-status.md"],
             },
           ],
         },

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

@@ -528,8 +528,8 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
           estimate: "15m",
           files: ["src/resources/extensions/gsd/tools/workflow-tool-executors.ts"],
           verify: "node --test",
-          inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
-          expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
+          inputs: [],
+          expectedOutput: ["src/bridge-status.md"],
         },
       ],
     }, base));