@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.822c9439

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

@@ -22,8 +22,8 @@ import {
   createAutoOrchestrator,
   decideOrchestratorDispatch,
   resolveLiveOrchestratorBasePath,
-  STUCK_WINDOW_SIZE,
 } from "../auto/orchestrator.js";
+import { STUCK_WINDOW_SIZE } from "../auto/dispatch-history.js";
 import type { OrchestratorContext } from "../auto/orchestrator.js";
 import type { AutoOrchestrationModule, AutoSessionContext } from "../auto/contracts.js";
 import type { GSDState } from "../types.js";
@@ -41,6 +41,10 @@ import {
   openDatabase,
 } from "../gsd-db.js";
 import { AutoSession } from "../auto/session.js";
+import { registerAutoWorker } from "../db/auto-workers.js";
+import { claimMilestoneLease } from "../db/milestone-leases.js";
+import { recordDispatchClaim, markFailed } from "../db/unit-dispatches.js";
+import { normalizeRealPath } from "../paths.js";
 import { acquireSessionLock, releaseSessionLock } from "../session-lock.js";
 import { queryJournal } from "../journal.js";
 import { invalidateAllCaches } from "../cache.js";
@@ -518,13 +522,12 @@ test("advance() is idempotent for the same active unit", async (t) => {
   if (first.kind === "advanced") {
     assert.deepEqual(first.unit, { unitType: "execute-task", unitId: "M001/S01/T01" });
   }
-  assert.equal(second.kind, "blocked");
-  if (second.kind !== "blocked") return;
+  assert.equal(second.kind, "skipped");
+  if (second.kind !== "skipped") return;
   assert.equal(second.reason, "idempotent advance: unit already active");
-  assert.equal(second.action, "pause");
 });
 
-test("idempotency block fires with its own reason before saturation", async (t) => {
+test("idempotency skip fires with its own reason before saturation", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
 
@@ -532,10 +535,9 @@ test("idempotency block fires with its own reason before saturation", async (t)
   const second = await f.orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
-  assert.equal(second.kind, "blocked");
-  if (second.kind !== "blocked") return;
+  assert.equal(second.kind, "skipped");
+  if (second.kind !== "skipped") return;
   assert.equal(second.reason, "idempotent advance: unit already active");
-  assert.equal(second.action, "pause");
 });
 
 test("completeActiveUnit clears in-flight idempotency and stops stale same-unit advance", async (t) => {
@@ -671,12 +673,12 @@ test("resume() clears idempotent lock and allows re-advance", async (t) => {
   t.after(() => f.cleanup());
 
   const first = await f.orchestrator.advance();
-  const blocked = await f.orchestrator.advance();
+  const idempotent = await f.orchestrator.advance();
   const resumed = await f.orchestrator.resume();
   const next = await f.orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
-  assert.equal(blocked.kind, "blocked");
+  assert.equal(idempotent.kind, "skipped");
   assert.equal(resumed.kind, "resumed");
   assert.equal(next.kind, "advanced");
 });
@@ -686,11 +688,11 @@ test("start() clears prior idempotent lock", async (t) => {
   t.after(() => f.cleanup());
 
   await f.orchestrator.advance();
-  const blocked = await f.orchestrator.advance();
+  const idempotent = await f.orchestrator.advance();
   const restarted = await f.orchestrator.start(SESSION_CONTEXT);
   const next = await f.orchestrator.advance();
 
-  assert.equal(blocked.kind, "blocked");
+  assert.equal(idempotent.kind, "skipped");
   assert.equal(restarted.kind, "started");
   assert.equal(next.kind, "advanced");
 });
@@ -700,32 +702,28 @@ test("stop() clears idempotent unit lock so advance can run again", async (t) =>
   t.after(() => f.cleanup());
 
   const first = await f.orchestrator.advance();
-  const blocked = await f.orchestrator.advance();
+  const idempotent = await f.orchestrator.advance();
   const stopped = await f.orchestrator.stop("reset");
   const second = await f.orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
-  assert.equal(blocked.kind, "blocked");
+  assert.equal(idempotent.kind, "skipped");
   assert.equal(stopped.kind, "stopped");
   assert.equal(second.kind, "advanced");
 });
 
-test("blocked path journals advance-blocked and records a health snapshot", async (t) => {
+test("idempotent path journals advance-skipped and records a health snapshot", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
 
   await f.orchestrator.advance();
   await f.orchestrator.advance();
 
-  assert.ok(f.journalNames().includes("advance-blocked"));
+  assert.ok(f.journalNames().includes("advance-skipped"));
 });
 
 // ─── Stuck-loop ring buffer (issue #5787) ──────────────────────────────────
 
-test("STUCK_WINDOW_SIZE matches the legacy auto/phases.ts constant", () => {
-  assert.equal(STUCK_WINDOW_SIZE, 6);
-});
-
 test("stuck-loop: empty ring on a freshly constructed orchestrator advances normally", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
@@ -761,21 +759,24 @@ test("stuck-loop: ring saturated with same unit blocks with action 'stop' and st
   // First call advances.
   assert.equal(results[0].kind, "advanced");
 
-  // Intermediate calls are blocked by idempotency (not stuck-loop yet).
+  // Intermediate calls are skipped by idempotency (not stuck-loop yet).
   for (let i = 1; i < STUCK_WINDOW_SIZE - 1; i++) {
     const r = results[i];
-    assert.equal(r.kind, "blocked", `round ${i} should be blocked`);
-    if (r.kind !== "blocked") return;
+    assert.equal(r.kind, "skipped", `round ${i} should be skipped`);
+    if (r.kind !== "skipped") return;
     assert.equal(r.reason, "idempotent advance: unit already active");
-    assert.equal(r.action, "pause");
   }
 
-  // The final call (ring now holds STUCK_WINDOW_SIZE copies) returns stuck-loop.
+  // The final call (ring now holds STUCK_WINDOW_SIZE copies) returns stuck-loop
+  // with the detect-stuck rule verdict in the reason.
   const last = results[STUCK_WINDOW_SIZE - 1];
   assert.equal(last.kind, "blocked");
   if (last.kind !== "blocked") return;
   assert.equal(last.action, "stop");
-  assert.equal(last.reason, `stuck-loop: execute-task:M001/S01/T01 picked ${STUCK_WINDOW_SIZE} times`);
+  assert.ok(
+    last.reason.startsWith("stuck-loop: execute-task:M001/S01/T01 derived"),
+    `expected detect-stuck verdict reason, got: ${last.reason}`,
+  );
 });
 
 test("stuck-loop: start() resets the ring so a fresh saturation cycle is required", async (t) => {
@@ -855,6 +856,80 @@ test("stuck-loop: stop('user-request') resets the ring (hard stop)", async (t) =
   assert.equal(next.kind, "advanced");
 });
 
+test("stuck-loop #482 regression: start() rehydrates the window from the dispatch ledger so cross-session re-dispatch loops are detected", async (t) => {
+  const f = makeFixture();
+  t.after(() => f.cleanup());
+
+  // Simulate a PRIOR session: the dispatch ledger recorded the same unit
+  // being re-dispatched repeatedly without progress. The orchestrator under test is a
+  // fresh instance (as it would be after a session restart) — before the
+  // Dispatch History module, start() reset the window to [] and the loop
+  // would silently re-dispatch the unit forever (#482: 146 re-dispatches).
+  const worker = registerAutoWorker({ projectRootRealpath: normalizeRealPath(f.base) });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `prior-session-${i}`,
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "" });
+  }
+
+  const started = await f.orchestrator.start(SESSION_CONTEXT);
+  assert.equal(started.kind, "started");
+
+  // The very next decision for the same unit must trip the stuck verdict
+  // instead of advancing.
+  const result = await f.orchestrator.advance();
+  assert.equal(result.kind, "blocked");
+  if (result.kind !== "blocked") return;
+  assert.equal(result.action, "stop");
+  assert.ok(result.reason.startsWith("stuck-loop:"), `expected stuck-loop reason, got: ${result.reason}`);
+});
+
+test("stuck-loop #482: resume() with an empty window rehydrates from the dispatch ledger", async (t) => {
+  const f = makeFixture();
+  t.after(() => f.cleanup());
+
+  const worker = registerAutoWorker({ projectRootRealpath: normalizeRealPath(f.base) });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `prior-session-resume-${i}`,
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "" });
+  }
+
+  // Fresh orchestrator resuming a prior session: window starts empty, so
+  // resume() must rehydrate (while in-process resume keeps the live window —
+  // see the #572 preservation tests above).
+  const resumed = await f.orchestrator.resume();
+  assert.equal(resumed.kind, "resumed");
+
+  const result = await f.orchestrator.advance();
+  assert.equal(result.kind, "blocked");
+  if (result.kind !== "blocked") return;
+  assert.equal(result.action, "stop");
+  assert.ok(result.reason.startsWith("stuck-loop:"), `expected stuck-loop reason, got: ${result.reason}`);
+});
+
 test("stuck-loop: journal records the stuck-loop reason on advance-blocked", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
@@ -1148,6 +1223,103 @@ test("decideOrchestratorDispatch forwards constructor session when advance input
   }
 });
 
+test("decideOrchestratorDispatch evaluates deep pre-planning rules without an active milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-no-active-"));
+  t.after(() => {
+    resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+  });
+  resetRegistry();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "workflow_prefs_captured: true",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: null,
+    phase: "pre-planning",
+    nextAction: "All remaining milestones are parked (M027). Run /gsd unpark M027 or create a new milestone.",
+    registry: [{ id: "M027", title: "Parked", status: "parked" }],
+  };
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const pi = { getActiveTools: () => [] } as never;
+  const session = {
+    basePath: base,
+    originalBasePath: base,
+    currentMilestoneId: "M027",
+  } as never;
+
+  const result = await decideOrchestratorDispatch(ctx, pi, base, session, { stateSnapshot });
+
+  assert.ok(result && "unitType" in result, `expected project-level dispatch, got ${JSON.stringify(result)}`);
+  assert.equal(result.unitType, "discuss-project");
+  assert.equal(result.unitId, "PROJECT");
+});
+
+test("decideOrchestratorDispatch does not replay milestone-scoped verification retry when no milestone is active", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-no-active-retry-"));
+  t.after(() => {
+    resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+  });
+  resetRegistry();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "workflow_prefs_captured: true",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: null,
+    phase: "pre-planning",
+    nextAction: "All remaining milestones are parked (M027). Run /gsd unpark M027 or create a new milestone.",
+    registry: [{ id: "M027", title: "Parked", status: "parked" }],
+  };
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const pi = { getActiveTools: () => [] } as never;
+  const stalePendingRetry = {
+    unitType: "execute-task",
+    unitId: "M027.S1.T1",
+    prompt: "stale retry prompt",
+    pauseAfterUatDispatch: false,
+    state: stateSnapshot,
+    mid: "M027",
+    midTitle: "Parked",
+  };
+  const session = {
+    basePath: base,
+    originalBasePath: base,
+    currentMilestoneId: "M027",
+    pendingVerificationRetryDispatch: stalePendingRetry,
+  } as never;
+
+  const result = await decideOrchestratorDispatch(ctx, pi, base, session, { stateSnapshot });
+
+  assert.ok(result && "unitType" in result, `expected project-level dispatch, got ${JSON.stringify(result)}`);
+  assert.equal(result.unitType, "discuss-project");
+  assert.equal(result.unitId, "PROJECT");
+  // The stale retry must be preserved for a future tick, not consumed by this
+  // no-active-milestone path (mirrors pre-#712-fix behavior where !active
+  // returned null before touching the retry).
+  const sess = session as unknown as { pendingVerificationRetryDispatch: unknown };
+  assert.equal(sess.pendingVerificationRetryDispatch, stalePendingRetry);
+});
+
 test("decideOrchestratorDispatch adopts next active milestone after the session milestone is closed", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-milestone-adopt-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -306,7 +306,9 @@ test("pauseAuto records the expected worktree path when paused from project root
 
     const meta = readPausedSessionMetadata(base);
     assert.ok(meta);
-    assert.equal(meta.worktreePath, join(base, ".gsd", "worktrees", "M001"));
+    // No worktree exists yet, so the recorded path is the canonical
+    // .gsd-worktrees/ creation location (worktree-placement seam).
+    assert.equal(meta.worktreePath, join(base, ".gsd-worktrees", "M001"));
   } finally {
     autoSession.reset();
     try {

package/src/resources/extensions/gsd/tests/auto-post-unit-evidence-crossref-4909.test.ts

@@ -88,3 +88,49 @@ test("detects session execution tools supported by the evidence collector", () =
 
   assert.equal(_hasExecutionToolCallsInSessionForTest(entries), true);
 });
+
+test("detects execution tool calls in bare agent-end messages (no session-entry wrapper)", () => {
+  // The auto loop passes opts.agentEndMessages as bare {role, content}
+  // messages — not {type: "message", message} session-manager entries.
+  const entries = [
+    {
+      role: "assistant",
+      content: [
+        {
+          type: "toolCall",
+          name: "Bash",
+          arguments: { command: "test -s index.html && grep -q localStorage index.html" },
+        },
+      ],
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), true);
+});
+
+test("does not suppress for bare agent-end messages without execution tools", () => {
+  const entries = [
+    {
+      role: "assistant",
+      content: [
+        { type: "text", text: "Task complete." },
+        { type: "toolCall", name: "Write", arguments: { file_path: "index.html" } },
+      ],
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), false);
+});
+
+test("ignores bare user messages with toolCall-shaped content", () => {
+  const entries = [
+    {
+      role: "user",
+      content: [
+        { type: "toolCall", name: "bash", arguments: { command: "echo hi" } },
+      ],
+    },
+  ];
+
+  assert.equal(_hasExecutionToolCallsInSessionForTest(entries), false);
+});

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -1,12 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkRemoteAutoSession } from "../auto.ts";
+import { checkRemoteAutoSession, forceStopAutoRemote } from "../auto.ts";
 import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.ts";
 import { normalizeRealPath } from "../paths.ts";
 import { readCrashLock } from "../crash-recovery.ts";
 
@@ -35,6 +36,29 @@ function setWorkerPid(workerId: string, pid: number): void {
   ).run({ ":pid": pid, ":worker_id": workerId });
 }
 
+function insertMilestone(id: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO milestones (id, title, status, created_at)
+     VALUES (:id, :title, 'active', :created_at)`,
+  ).run({
+    ":id": id,
+    ":title": id,
+    ":created_at": new Date().toISOString(),
+  });
+}
+
+function writeLegacyLock(base: string, pid: number): void {
+  const now = new Date().toISOString();
+  writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify({
+    pid,
+    startedAt: now,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: now,
+  }));
+}
+
 function findDeadPidCandidate(): number {
   const candidates = [99_999, 199_999, 299_999, 399_999];
   for (const pid of candidates) {
@@ -62,3 +86,41 @@ test("checkRemoteAutoSession clears stale lock state when lock PID is dead", (t)
   assert.deepEqual(remote, { running: false });
   assert.equal(readCrashLock(base), null, "stale lock should be cleared by remote session check");
 });
+
+test("forceStopAutoRemote escalates a live remote PID and releases worker state", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 424_242;
+  setWorkerPid(workerId, pid);
+  insertMilestone("M001");
+  writeLegacyLock(base, pid);
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true, "precondition: worker holds a milestone lease");
+
+  const signals: Array<NodeJS.Signals | 0> = [];
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    return true;
+  }) as typeof process.kill;
+  t.after(() => {
+    process.kill = originalKill;
+  });
+
+  const result = forceStopAutoRemote(base);
+
+  assert.deepEqual(result, { found: true, pid });
+  assert.ok(signals.includes("SIGTERM"), "force stop should request graceful termination first");
+  assert.ok(signals.includes("SIGKILL"), "force stop should escalate when the PID is still alive");
+  assert.equal(getAutoWorker(workerId)?.status, "stopping");
+  assert.equal(
+    getMilestoneLease("M001")?.status,
+    "released",
+    "force stop should release held milestone leases",
+  );
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});

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

@@ -184,7 +184,7 @@ describe("auto-worktree workspace registry", () => {
     git(["commit", "-m", "add milestone"], tempDir);
 
     createAutoWorktree(tempDir, "M003");
-    const wtDir = join(tempDir, ".gsd", "worktrees", "M003");
+    const wtDir = join(tempDir, ".gsd-worktrees", "M003");
     writeFileSync(join(wtDir, "feature.txt"), "implemented\n");
     git(["add", "feature.txt"], wtDir);
     git(["commit", "-m", "feat: implement M003"], wtDir);
@@ -216,7 +216,7 @@ describe("auto-worktree workspace registry", () => {
     git(["commit", "-m", "add milestone"], tempDir);
 
     createAutoWorktree(tempDir, "M004");
-    const wtDir = join(tempDir, ".gsd", "worktrees", "M004");
+    const wtDir = join(tempDir, ".gsd-worktrees", "M004");
     writeFileSync(join(wtDir, "feature.txt"), "implemented\n");
     git(["add", "feature.txt"], wtDir);
     git(["commit", "-m", "feat: implement M004"], wtDir);

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

@@ -35,7 +35,8 @@ test("repair target accepts a missing expected milestone worktree", () => {
 
     assert.equal(result.ok, true);
     if (result.ok) {
-      assert.equal(result.expectedPath, join(base, ".gsd", "worktrees", "M001"));
+      // No worktree exists yet, so the expected path is the canonical container.
+      assert.equal(result.expectedPath, join(base, ".gsd-worktrees", "M001"));
     }
   } finally {
     cleanup(base);
@@ -192,7 +193,8 @@ test("paused metadata path resolves to the expected worktree while paused at pro
       baseIsAutoWorktree: false,
     });
 
-    assert.equal(result, join(base, ".gsd", "worktrees", "M001"));
+    // No worktree exists yet, so resolution lands at the canonical container.
+    assert.equal(result, join(base, ".gsd-worktrees", "M001"));
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/blocked-models.test.ts

@@ -8,7 +8,10 @@ import { join } from "node:path";
 
 import {
   blockModel,
+  blockModelUntil,
+  clearTemporaryModelBlocksForTest,
   isModelBlocked,
+  isModelTemporarilyUnavailable,
   loadBlockedModels,
 } from "../blocked-models.ts";
 
@@ -96,3 +99,19 @@ test("blocked-models: file created under .gsd/runtime/", () => {
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("blocked-models: temporary rate-limit blocks expire without persisting", () => {
+  const base = mkBase();
+  try {
+    clearTemporaryModelBlocksForTest();
+    blockModelUntil(base, "openai-codex", "gpt-5.5", Date.now() + 60_000, "session limit");
+    assert.equal(isModelTemporarilyUnavailable(base, "openai-codex", "gpt-5.5"), true);
+    assert.equal(loadBlockedModels(base).length, 0, "rate-limit windows must not persist as account blocks");
+
+    blockModelUntil(base, "openai-codex", "gpt-5.5", Date.now() - 1, "expired");
+    assert.equal(isModelTemporarilyUnavailable(base, "openai-codex", "gpt-5.5"), false);
+  } finally {
+    clearTemporaryModelBlocksForTest();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/browser-automation-contract-fixture.ts

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+
+import {
+	getUatBrowserToolSupportError,
+	hasUatBrowserToolSurface,
+	type UatType,
+} from "../uat-policy.ts";
+
+export const BROWSER_AUTOMATION_CONTRACT_TOOLS = {
+	piProvider: ["read", "browser_navigate"],
+	externalMcpClient: ["read", "mcp__gsd-browser__browser_navigate"],
+	externalMcpWildcard: ["read", "mcp__gsd-browser__*"],
+	otherBrowserMcp: ["read", "mcp__browser-uat__*"],
+	workflowOnly: ["read", "mcp__gsd-workflow__*"],
+	withoutBrowser: ["read", "gsd_uat_exec"],
+} as const;
+
+export function assertBrowserAutomationContractAvailable(tools: readonly string[]): void {
+	assert.equal(hasUatBrowserToolSurface(tools), true, `${tools.join(", ")} should satisfy the Browser Automation Contract`);
+}
+
+export function assertBrowserAutomationContractMissing(tools: readonly string[] | undefined): void {
+	assert.equal(hasUatBrowserToolSurface(tools), false, `${tools?.join(", ") ?? "undefined"} should not satisfy the Browser Automation Contract`);
+}
+
+export function assertBrowserBackedUatCanDispatch(options: {
+	uatType: UatType;
+	activeTools: readonly string[] | undefined;
+	registeredTools?: readonly string[];
+}): void {
+	assert.equal(
+		getUatBrowserToolSupportError({
+			...options,
+			milestoneId: "M001",
+			sliceId: "S01",
+		}),
+		null,
+	);
+}

package/src/resources/extensions/gsd/tests/browser-contract.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  BROWSER_CONTRACT_TOOL_NAMES,
+  BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES,
+  hasBrowserContractPrefix,
+  isBrowserContractToolName,
+} from "../../shared/browser-contract.ts";
+import { isUatBrowserToolName } from "../uat-policy.ts";
+import { BROWSER_REQUIREMENT_RE, BROWSER_RUNTIME_RE } from "../browser-evidence.ts";
+
+// Note: RUN_UAT_BROWSER_TOOL_NAMES and MANAGED_GSD_BROWSER_TOOL_NAMES are
+// reference-equal aliases of BROWSER_CONTRACT_TOOL_NAMES, and the managed
+// adapter's spec table is Record-keyed by BrowserContractToolName — both
+// derivations are pinned by the type system, not by runtime assertions here.
+describe("Browser Automation Contract parity", () => {
+  it("every contract name satisfies the UAT browser-tool predicate, bare and MCP-prefixed", () => {
+    for (const name of BROWSER_CONTRACT_TOOL_NAMES) {
+      assert.equal(isUatBrowserToolName(name), true, name);
+      assert.equal(isUatBrowserToolName(`mcp__gsd-browser__${name}`), true, `mcp__gsd-browser__${name}`);
+    }
+  });
+
+  it("contract names are canonical browser_* names with no duplicates", () => {
+    assert.equal(new Set(BROWSER_CONTRACT_TOOL_NAMES).size, BROWSER_CONTRACT_TOOL_NAMES.length);
+    for (const name of BROWSER_CONTRACT_TOOL_NAMES) {
+      assert.equal(hasBrowserContractPrefix(name), true, name);
+      assert.equal(isBrowserContractToolName(name), true, name);
+    }
+    assert.equal(isBrowserContractToolName("browser_not_a_real_tool"), false);
+    assert.equal(hasBrowserContractPrefix("gsd_uat_exec"), false);
+  });
+
+  it("evidence-signal names stay a subset of the contract and drive the detection regexes", () => {
+    for (const name of BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES) {
+      assert.equal(isBrowserContractToolName(name), true, name);
+      // Identifier-shaped names keep the regex splice in browser-evidence.ts escape-free.
+      assert.match(name, /^browser_[a-z_]+$/);
+      assert.match(`Verified via ${name} call`, BROWSER_REQUIREMENT_RE);
+      assert.match(`Verified via ${name} call`, BROWSER_RUNTIME_RE);
+    }
+  });
+});