@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

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

@@ -21,6 +21,14 @@ function runGit(args: string[], cwd: string): void {
   });
 }
 
+function renderOutcomeWidget(widget: unknown): string {
+  const component = (widget as any)(
+    { requestRender() {} },
+    { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+  );
+  return component.render(100).join("\n");
+}
+
 test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
   const previousCwd = process.cwd();
@@ -167,13 +175,17 @@ test("cleanupAfterLoopExit preserves completion closeout surface after stopAuto
       false,
       "completion cleanup must not replace the closeout surface with a generic outcome card",
     );
-    assert.equal(autoSession.completionStopInProgress, false);
+    assert.equal(
+      autoSession.completionStopInProgress,
+      true,
+      "completion closeout preservation must survive post-loop cleanup until the next agent turn",
+    );
   } finally {
     autoSession.reset();
   }
 });
 
-test("cleanupAfterLoopExit clears completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
+test("cleanupAfterLoopExit preserves completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -196,8 +208,8 @@ test("cleanupAfterLoopExit clears completionStopInProgress even when preserveSte
 
     assert.equal(
       autoSession.completionStopInProgress,
-      false,
-      "completionStopInProgress must be cleared even when preserveStepSurfaceAfterLoopExit was also set",
+      true,
+      "completionStopInProgress must survive cleanup even when preserveStepSurfaceAfterLoopExit was also set",
     );
     assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
   } finally {
@@ -294,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 {
@@ -641,6 +655,10 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       false,
       "foreground completion stop must not install a replacement roll-up widget over the transcript",
     );
+    assert.ok(
+      widgetCalls.some(([key, value]) => key === "gsd-progress" && value === undefined),
+      "foreground completion stop must clear stale progress controls in the rerooted session",
+    );
     assert.ok(
       notifications.every(message => !message.includes("/gsd auto to resume")),
       "completion stop notification must not tell users to resume a finished auto run",
@@ -649,10 +667,15 @@ test("stopAuto foreground completion closeout reroots session and preserves the
       notifications.every(message => !message.includes("Auto-mode stopped") && !message.includes("Session:") && !message.includes("Debug log written")),
       "completion stop must not append generic stop/session/debug notifications after the report",
     );
-    assert.ok(
-      widgetCalls.every(([key, value]) => key !== "gsd-outcome" || value === undefined),
-      "foreground completion stop must not replace the transcript with a generic outcome card",
+    const outcome = widgetCalls.find(([key, value]) => key === "gsd-outcome" && typeof value === "function")?.[1];
+    assert.equal(
+      typeof outcome,
+      "function",
+      "foreground completion stop must install a durable closeout outcome in the rerooted session",
     );
+    const rendered = renderOutcomeWidget(outcome);
+    assert.match(rendered, /Milestone M003 complete/);
+    assert.match(rendered, /Review the closeout/);
 
     const widgetCallCountBeforePostLoopCleanup = widgetCalls.length;
     await cleanupAfterLoopExit(ctx);
@@ -822,7 +845,7 @@ test("stopAuto closeout-transcript preservation suppresses generic stop widgets"
   }
 });
 
-test("stopAuto foreground all-complete closeout preserves the transcript surface", async () => {
+test("stopAuto foreground all-complete closeout installs a durable terminal outcome", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-all-complete-closeout-"));
   const previousCwd = process.cwd();
   const widgetCalls: Array<[string, unknown]> = [];
@@ -875,8 +898,15 @@ test("stopAuto foreground all-complete closeout preserves the transcript surface
       false,
       "foreground all-complete closeout must not replace the visible transcript with a roll-up widget",
     );
-    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1);
-    assert.equal(finalOutcome?.[1], undefined, "foreground all-complete closeout must not add an outcome replacement");
+    const finalOutcome = widgetCalls.filter(([key]) => key === "gsd-outcome").at(-1)?.[1];
+    assert.equal(
+      typeof finalOutcome,
+      "function",
+      "foreground all-complete closeout must install a durable terminal outcome",
+    );
+    const rendered = renderOutcomeWidget(finalOutcome);
+    assert.match(rendered, /All milestones complete/);
+    assert.match(rendered, /start new work/);
   } finally {
     try { closeDatabase(); } catch { /* noop */ }
     autoSession.reset();

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-runtime-state.test.ts

@@ -6,12 +6,15 @@ import assert from "node:assert/strict";
 
 import {
   autoSession,
+  clearAutoToolSurfaceSnapshot,
   clearToolInvocationError,
   getAutoRuntimeSnapshot,
+  recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
   autoSession.active = true;
   autoSession.basePath = "/tmp/project";
   autoSession.orchestration = {
@@ -33,10 +36,40 @@ test("getAutoRuntimeSnapshot includes orchestration phase when available", () =>
   assert.equal(snap.orchestrationPhase, "running");
   assert.equal(snap.orchestrationTransitionCount, 3);
   assert.equal(snap.orchestrationLastTransitionAt, 123);
+  assert.equal(snap.toolSurface, null);
 
   autoSession.reset();
 });
 
+test("getAutoRuntimeSnapshot includes the active typed tool-surface snapshot", () => {
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+  autoSession.active = true;
+
+  recordAutoToolSurfaceSnapshot({
+    source: "dispatch-scope",
+    unitType: "run-uat",
+    modelFacingToolNames: ["read", "read", "gsd_uat_exec"],
+    registeredToolNames: ["read", "browser_navigate"],
+    scopedToolNames: ["read", "browser_navigate"],
+    presentedToolNames: ["gsd_uat_exec"],
+    capturedAt: 123,
+  });
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.toolSurface?.source, "dispatch-scope");
+  assert.equal(snap.toolSurface?.unitType, "run-uat");
+  assert.deepEqual(snap.toolSurface?.modelFacingToolNames, ["read", "gsd_uat_exec"]);
+  assert.deepEqual(snap.toolSurface?.registeredToolNames, ["read", "browser_navigate"]);
+  assert.deepEqual(snap.toolSurface?.scopedToolNames, ["read", "browser_navigate"]);
+  assert.deepEqual(snap.toolSurface?.presentedToolNames, ["gsd_uat_exec"]);
+  assert.equal(snap.toolSurface?.capturedAt, 123);
+
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+});
+
 test("clearToolInvocationError clears stale tool error state for active auto sessions", () => {
   autoSession.reset();
   autoSession.active = true;
@@ -56,4 +89,5 @@ test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", ()
   assert.equal(snap.orchestrationPhase, undefined);
   assert.equal(snap.orchestrationTransitionCount, undefined);
   assert.equal(snap.orchestrationLastTransitionAt, undefined);
+  assert.equal(snap.toolSurface, null);
 });

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);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/browser-daemon-auto-prep.test.ts

@@ -0,0 +1,144 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  prepareBrowserDaemonForUat,
+  shouldWarmBrowserDaemonForUat,
+} from "../browser-daemon-auto-prep.ts";
+import { commitBrowserEngineResolution } from "../../browser-tools/engine/selection.ts";
+import { resolveGsdBrowserCliAvailability } from "../../shared/gsd-browser-cli.ts";
+
+const GSD_BROWSER_ENGINE = { GSD_BROWSER_ENGINE: "gsd-browser" } as const;
+
+test("shouldWarmBrowserDaemonForUat skips artifact-driven UAT", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "artifact-driven",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat enables Claude Code browser UAT when gsd-browser is available", (t) => {
+  const availability = resolveGsdBrowserCliAvailability();
+  if (!availability.available) {
+    t.skip("bundled gsd-browser CLI unavailable");
+  }
+
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "externalCli",
+      projectRoot: "/tmp/project",
+      env: GSD_BROWSER_ENGINE,
+    }),
+    true,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat enables warm-up for Claude Code oauth/apiKey when engine is gsd-browser", (t) => {
+  const availability = resolveGsdBrowserCliAvailability();
+  if (!availability.available) {
+    t.skip("bundled gsd-browser CLI unavailable");
+  }
+
+  for (const sessionAuthMode of ["oauth", "apiKey"] as const) {
+    assert.equal(
+      shouldWarmBrowserDaemonForUat({
+        uatType: "browser-executable",
+        sessionProvider: "claude-code",
+        sessionAuthMode,
+        sessionBaseUrl: "https://api.anthropic.com",
+        projectRoot: "/tmp/project",
+        env: GSD_BROWSER_ENGINE,
+      }),
+      true,
+      `expected warm-up for sessionAuthMode=${sessionAuthMode}`,
+    );
+  }
+});
+
+test("shouldWarmBrowserDaemonForUat skips legacy Playwright engine for Claude Code", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "oauth",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_ENGINE: "legacy" },
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat uses session-committed ambient engine for non-Claude providers", () => {
+  const projectRoot = "/tmp/ambient-engine-project";
+  commitBrowserEngineResolution(projectRoot, {
+    engine: "legacy",
+    source: "probe",
+    reason: "gsd-browser daemon connect failed (test); using legacy Playwright",
+  });
+
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "openai",
+      projectRoot,
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat skips when browser MCP is disabled", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_MCP_ENABLED: "0" },
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat skips when warm-up is disabled", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_WARMUP: "0" },
+    }),
+    false,
+  );
+});
+
+test("prepareBrowserDaemonForUat returns null when warm-up is not required", () => {
+  assert.equal(
+    prepareBrowserDaemonForUat({
+      uatType: "artifact-driven",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "externalCli",
+      projectRoot: "/tmp/example-project",
+    }),
+    null,
+  );
+});
+
+test("prepareBrowserDaemonForUat returns actionable error when daemon start fails", () => {
+  const error = prepareBrowserDaemonForUat({
+    uatType: "browser-executable",
+    sessionProvider: "claude-code",
+    sessionAuthMode: "externalCli",
+    projectRoot: "/tmp/example-project",
+    env: {
+      ...GSD_BROWSER_ENGINE,
+      GSD_BROWSER_MCP_COMMAND: "/definitely/missing/gsd-browser",
+    },
+  });
+
+  assert.match(error ?? "", /gsd-browser daemon failed to start/i);
+});

package/src/resources/extensions/gsd/tests/canonical-milestone-root.test.ts

@@ -17,6 +17,7 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.ts";
+import { resolveCloseoutArtifactProjection } from "../artifact-projection.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-canon-test-${randomUUID()}`);
@@ -106,3 +107,22 @@ test("only returns the worktree for the requested milestone, not siblings", () =
     cleanup(base);
   }
 });
+
+test("resolveCloseoutArtifactProjection names project and canonical artifact roots", () => {
+  const base = makeTmpBase();
+  try {
+    const wtPath = makeLiveWorktree(base, "M001");
+    const projection = resolveCloseoutArtifactProjection({
+      milestoneId: "M001",
+      basePath: wtPath,
+      originalBasePath: base,
+    });
+
+    assert.equal(projection.projectRoot, base);
+    assert.equal(projection.canonicalMilestoneRoot, wtPath);
+    assert.equal(projection.summaryArtifactBasePath, wtPath);
+    assert.equal(projection.gateEvidenceBasePath, wtPath);
+  } finally {
+    cleanup(base);
+  }
+});