@opengsd/gsd-pi 1.6.0 → 1.7.0

package/packages/gsd-cloud/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@opengsd/gsd-cloud",
+  "version": "1.7.0",
+  "description": "Thin CLI wrapper that connects a local GSD runtime to GSD Cloud (cloud.opengsd.net)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-gsd/gsd-pi.git",
+    "directory": "packages/gsd-cloud"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "gsd-cloud": "./bin/gsd-cloud.js"
+  },
+  "scripts": {
+    "build": "node ../../scripts/clean-package-dist.cjs && tsc",
+    "test": "pnpm run build && node --test dist/inject-gateway.test.js"
+  },
+  "dependencies": {
+    "@opengsd/daemon": "^1.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "README.md",
+    "bin",
+    "dist",
+    "!dist/**/*.test.*"
+  ]
+}

package/packages/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengsd/mcp-server",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "MCP server exposing GSD orchestration tools for compatible clients",
   "license": "MIT",
   "gsd": {
@@ -50,9 +50,9 @@
     "test": "pnpm run build:test && node --test dist/mcp-server.test.js dist/remote-questions.test.js dist/moonshot-tool-schema.test.js dist/pid-registry.test.js dist/probe-mode.test.js dist/stdio-watchdog.test.js dist/cli-runner.test.js dist/readers/graph.test.js dist/readers/paths.test.js dist/readers/readers.test.js"
   },
   "dependencies": {
-    "@gsd/pi-ai": "^1.6.0",
-    "@opengsd/contracts": "^1.6.0",
-    "@opengsd/rpc-client": "^1.6.0",
+    "@gsd/pi-ai": "^1.7.0",
+    "@opengsd/contracts": "^1.7.0",
+    "@opengsd/rpc-client": "^1.7.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "zod": "^4.0.0"
   },

package/packages/native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/native",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Native Rust bindings for GSD — high-performance native modules via N-API",
   "type": "commonjs",
   "gsd": {

package/packages/pi-agent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-agent-core",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "General-purpose agent with transport abstraction, state management, and attachment support",
   "type": "module",
   "gsd": {

package/packages/pi-ai/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-ai",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Unified LLM API with automatic model discovery and provider configuration",
   "type": "module",
   "gsd": {

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Coding agent CLI (vendored from earendil-works/pi)",
   "type": "module",
   "gsd": {
@@ -33,7 +33,7 @@
     "copy-assets": "node scripts/copy-assets.cjs"
   },
   "dependencies": {
-    "@opengsd/contracts": "^1.6.0",
+    "@opengsd/contracts": "^1.7.0",
     "@mariozechner/jiti": "^2.6.2",
     "@silvia-odwyer/photon-node": "0.3.4",
     "chalk": "5.6.2",
@@ -53,11 +53,11 @@
     "typebox": "1.1.38",
     "undici": "7.28.0",
     "yaml": "2.9.0",
-    "@gsd/agent-core": "^1.6.0",
-    "@gsd/native": "^1.6.0",
-    "@gsd/pi-agent-core": "^1.6.0",
-    "@gsd/pi-ai": "^1.6.0",
-    "@gsd/pi-tui": "^1.6.0",
+    "@gsd/agent-core": "^1.7.0",
+    "@gsd/native": "^1.7.0",
+    "@gsd/pi-agent-core": "^1.7.0",
+    "@gsd/pi-ai": "^1.7.0",
+    "@gsd/pi-tui": "^1.7.0",
     "@sinclair/typebox": "^0.34.41"
   },
   "devDependencies": {

package/packages/pi-tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-tui",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Terminal UI library (vendored from earendil-works/pi)",
   "type": "module",
   "gsd": {
@@ -21,7 +21,7 @@
     "build": "node ../../scripts/clean-package-dist.cjs && tsc -p tsconfig.json --incremental false"
   },
   "dependencies": {
-    "@gsd/native": "^1.6.0",
+    "@gsd/native": "^1.7.0",
     "get-east-asian-width": "1.6.0",
     "marked": "15.0.12",
     "@sinclair/typebox": "^0.34.41"

package/packages/rpc-client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengsd/rpc-client",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Standalone RPC client SDK for GSD — zero internal dependencies",
   "license": "MIT",
   "gsd": {
@@ -34,7 +34,7 @@
     "test": "node --test dist/rpc-client.test.js"
   },
   "dependencies": {
-    "@opengsd/contracts": "^1.6.0"
+    "@opengsd/contracts": "^1.7.0"
   },
   "engines": {
     "node": ">=22.0.0"

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/browser-tools/tests/gsd-browser-launch-config.test.mjs

@@ -9,6 +9,7 @@ import { dirname, join } from "node:path";
 const {
   resolveBundledGsdBrowserCliPath,
   resolveGsdBrowserDaemonStartInvocation,
+  resolveGsdBrowserDaemonStopInvocation,
   resolveGsdBrowserMcpLaunchConfig,
 } = await import("../../shared/gsd-browser-cli.ts");
 
@@ -179,3 +180,21 @@ describe("resolveGsdBrowserDaemonStartInvocation", () => {
     );
   });
 });
+
+describe("resolveGsdBrowserDaemonStopInvocation", () => {
+  it("mirrors MCP session and identity flags with daemon stop", () => {
+    const launch = resolveGsdBrowserMcpLaunchConfig("/tmp/example-project", {});
+    const daemon = resolveGsdBrowserDaemonStopInvocation("/tmp/example-project", {});
+
+    assert.equal(daemon.command, launch.command);
+    assert.equal(daemon.cwd, launch.cwd);
+    assert.deepEqual(
+      daemon.args.slice(daemon.args.indexOf("--session")),
+      launch.args.slice(launch.args.indexOf("--session")),
+    );
+    assert.deepEqual(
+      daemon.args.slice(0, daemon.args.indexOf("--session")),
+      [...launch.args.slice(0, launch.args.indexOf("mcp")), "daemon", "stop"],
+    );
+  });
+});

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -56,7 +56,7 @@ import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, getMilestoneSlices, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { getWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { renderPlanCheckboxes, renderRoadmapFromDb, roadmapRenderMarksSliceDone } from "./markdown-renderer.js";
-import { consumeSignal } from "./session-status-io.js";
+import { awaitWorkerResume, consumeSignal } from "./session-status-io.js";
 import {
   checkPostUnitHooks,
   consumeHookFailure,
@@ -1279,8 +1279,27 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         return "dispatched";
       }
       if (signal.signal === "pause") {
-        await pauseAuto(ctx, pi);
-        return "dispatched";
+        // A worker `pause` is a *temporary* coordination request: the docs
+        // contract (docs/user-docs/parallel-orchestration.md) is "finish current
+        // unit, wait" followed by a matching `resume`. Only the interactive
+        // dashboard runtime owns a resumer — unattended `gsd headless auto` does
+        // not — so a terminal pauseAuto() here strands the worker at exit 10
+        // (BLOCKED) after its first unit, with nothing able to lift it (#1273).
+        // Wait for the coordinator to resume (or stop) us instead. If no resumer
+        // lifts the pause within the window, degrade to in-process serialization
+        // and continue the dispatch loop rather than halting the run forever.
+        const resumeOutcome = await awaitWorkerResume(s.basePath, milestoneLock);
+        if (resumeOutcome === "stop") {
+          await stopAuto(ctx, pi);
+          return "dispatched";
+        }
+        if (resumeOutcome === "timeout") {
+          logWarning(
+            "parallel",
+            `pause signal for ${milestoneLock} was not resumed (no headless resumer, #1273); continuing dispatch`,
+          );
+        }
+        // "resume" or "timeout": fall through and continue post-unit processing.
       }
     }
   }

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -2725,6 +2725,26 @@ export async function buildExecuteTaskPrompt(
   let phaseAnchorSection = planAnchor ? formatAnchorForPrompt(planAnchor) : "";
   trackPromptContext(contextTelemetry, "plan-anchor", phaseAnchorSection ? "inline" : "skipped", phaseAnchorSection, phaseAnchorSection ? undefined : "missing");
 
+  // #1272: inject a pending reopen reason into this task's prompt. When a gate
+  // (e.g. complete-slice's full-suite run) reopened the task via gsd_task_reopen
+  // with a diagnosis, surface it here so the re-dispatched executor fixes the
+  // regression instead of re-running the original (green) scoped verify. Claim
+  // is one-shot (artifact deleted on read). Not feature-gated — a reopened task
+  // must always know why. Prepended so it sits above the plan anchor.
+  try {
+    const { claimReopenReasonForInjection } = await import("./reopen-reason.js");
+    const reopenClaimed = claimReopenReasonForInjection(base, mid, sid, tid);
+    if (reopenClaimed) {
+      const block = reopenClaimed.injectionBlock + "\n\n---\n\n";
+      phaseAnchorSection = phaseAnchorSection
+        ? `${block}${phaseAnchorSection}`
+        : block;
+      trackPromptContext(contextTelemetry, "reopen-reason", "inline", reopenClaimed.injectionBlock);
+    }
+  } catch (reopenErr) {
+    logWarning("prompt", `reopen reason injection failed: ${(reopenErr as Error).message}`);
+  }
+
   // ADR-011 Phase 2: inject any resolved-but-unapplied escalation override
   // into this task's prompt. Claim is atomic via DB UPDATE WHERE IS NULL, so
   // if a parallel build already injected it, we skip. Feature-gated by

package/src/resources/extensions/gsd/auto.ts

@@ -185,6 +185,7 @@ import { enterAutoWorktree, isInAutoWorktree } from "./auto-worktree-entry.js";
 import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { checkResourcesStale, readResourceVersion } from "./auto-worktree-resource-version.js";
 import { escapeStaleWorktree } from "./auto-worktree-runtime-cleanup.js";
+import { teardownWarmedBrowserDaemons } from "./browser-daemon-auto-prep.js";
 import { getAutoWorktreeOriginalBase } from "./auto-worktree-session-registry.js";
 import { syncWorktreeStateBack } from "./auto-worktree-sync.js";
 import { teardownAutoWorktree } from "./auto-worktree-teardown.js";
@@ -1490,6 +1491,17 @@ export async function cleanupAfterLoopExit(ctx: ExtensionContext): Promise<void>
     logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
   }
 
+  // Symmetric teardown for the browser-UAT warm-up preflight (#1259): stop any
+  // gsd-browser daemon this session started so the Chrome process does not
+  // linger after the loop exits. Re-warms on the next browser-backed run-uat.
+  try {
+    for (const { projectRoot, error } of teardownWarmedBrowserDaemons()) {
+      logWarning("session", `gsd-browser daemon stop failed for ${projectRoot}: ${error}`, { file: "auto.ts" });
+    }
+  } catch (err) {
+    logWarning("session", `browser daemon teardown failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+  }
+
   // A transient provider-error pause intentionally leaves the paused badge
   // visible so the user still has a resumable auto-mode signal on screen.
   if (!s.paused) {

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

@@ -9,10 +9,19 @@ import {
 import {
   resolveGsdBrowserCliAvailability,
   resolveGsdBrowserDaemonStartInvocation,
+  resolveGsdBrowserDaemonStopInvocation,
 } from "../shared/gsd-browser-cli.js";
 import { uatTypeIncludesBrowser, type UatType } from "./uat-policy.js";
 
 const DEFAULT_DAEMON_START_TIMEOUT_MS = 30_000;
+const DEFAULT_DAEMON_STOP_TIMEOUT_MS = 15_000;
+
+/**
+ * Project roots whose gsd-browser daemon this process warmed via
+ * {@link prepareBrowserDaemonForUat}. Teardown only stops daemons we actually
+ * started, so non-browser auto-mode sessions never spawn a stray `daemon stop`.
+ */
+const warmedDaemonProjectRoots = new Set<string>();
 
 function isEnvDisabled(value: string | undefined): boolean {
   if (!value) return false;
@@ -102,7 +111,74 @@ export function prepareBrowserDaemonForUat(ctx: BrowserDaemonWarmContext): strin
   if (!shouldWarmBrowserDaemonForUat(ctx)) return null;
 
   const result = ensureBrowserDaemonStarted(ctx.projectRoot, { env: ctx.env });
-  if (result.ok) return null;
+  if (result.ok) {
+    warmedDaemonProjectRoots.add(resolve(ctx.projectRoot));
+    return null;
+  }
 
   return `Cannot dispatch browser-backed run-uat: gsd-browser daemon failed to start (${result.error}). Ensure Chrome/Chromium is installed, run \`gsd-browser daemon health\` with the project session flags from .mcp.json, or set GSD_BROWSER_PATH to a Chromium binary.`;
 }
+
+/**
+ * Best-effort stop of a gsd-browser session daemon warmed for browser UAT.
+ * Mirrors {@link ensureBrowserDaemonStarted}; returns the failure detail rather
+ * than throwing so teardown can stay non-fatal.
+ */
+export function stopBrowserDaemon(
+  projectRoot: string,
+  options: { env?: NodeJS.ProcessEnv; timeoutMs?: number } = {},
+): { ok: true } | { ok: false; error: string } {
+  const env = options.env ?? process.env;
+  const availability = resolveGsdBrowserCliAvailability(env);
+  if (!availability.available) {
+    return { ok: false, error: availability.detail };
+  }
+
+  let invocation: ReturnType<typeof resolveGsdBrowserDaemonStopInvocation>;
+  try {
+    invocation = resolveGsdBrowserDaemonStopInvocation(projectRoot, env);
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  try {
+    execFileSync(invocation.command, invocation.args, {
+      cwd: invocation.cwd,
+      env: { ...process.env, ...env, ...(invocation.env ?? {}) },
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: options.timeoutMs ?? DEFAULT_DAEMON_STOP_TIMEOUT_MS,
+      encoding: "utf-8",
+    });
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Tear down every gsd-browser daemon this process warmed for browser UAT,
+ * clearing the tracked set. Called on auto-mode loop exit so the Chrome process
+ * does not survive session/task completion (mirrors the warm-up preflight).
+ * Best-effort: returns the project roots whose stop failed for logging.
+ */
+export function teardownWarmedBrowserDaemons(
+  options: { env?: NodeJS.ProcessEnv } = {},
+): { projectRoot: string; error: string }[] {
+  if (warmedDaemonProjectRoots.size === 0) return [];
+
+  const failures: { projectRoot: string; error: string }[] = [];
+  for (const projectRoot of warmedDaemonProjectRoots) {
+    const result = stopBrowserDaemon(projectRoot, { env: options.env });
+    if (!result.ok) {
+      failures.push({ projectRoot, error: result.error });
+    }
+  }
+  warmedDaemonProjectRoots.clear();
+  return failures;
+}

package/src/resources/extensions/gsd/reopen-reason.ts

@@ -0,0 +1,109 @@
+// Project/App: gsd-pi
+// File Purpose: Persist a reopened task's failure diagnosis and inject it into the re-dispatched execute-task prompt.
+// GSD Extension — follow-up to #1225 (#1272)
+//
+// When complete-slice's gate reopens a task via gsd_task_reopen, the operator
+// supplies a `reason` explaining exactly what the full-suite gate caught and
+// how to fix it. That reason previously only landed in the workflow event log
+// (audit trail) and never reached the re-dispatched executor, so the executor
+// re-ran the original (green) verify and re-completed the task without touching
+// the regression. This module is the "inject unresolved context into the next
+// dispatch" mechanism for reopen reasons — a lightweight, file-based sibling of
+// escalation.js#claimOverrideForInjection, keyed by (milestone, slice, task).
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+import { legacyMilestonesDir, resolveSlicePath, resolveTasksDir } from "./paths.js";
+import { atomicWriteSync } from "./atomic-write.js";
+import { logWarning } from "./workflow-logger.js";
+
+interface ReopenReasonArtifact {
+  version: 1;
+  milestoneId: string;
+  sliceId: string;
+  taskId: string;
+  reason: string;
+  createdAt: string;
+}
+
+/**
+ * Canonical reopen-reason artifact path, parallel to T##-SUMMARY.md and
+ * T##-ESCALATION.json:
+ *   .gsd/milestones/{M}/slices/{S}/tasks/{T}-REOPEN.json
+ * Flat-phase: the artifact sits directly in the phase dir. Legacy layouts
+ * without a tasks/ subdir return null (caller degrades gracefully).
+ */
+export function reopenReasonArtifactPath(
+  basePath: string, milestoneId: string, sliceId: string, taskId: string,
+): string | null {
+  const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
+  if (tDir) return join(tDir, `${taskId}-REOPEN.json`);
+  if (existsSync(legacyMilestonesDir(basePath))) return null;
+  const phaseDir = resolveSlicePath(basePath, milestoneId, sliceId);
+  if (!phaseDir) return null;
+  return join(phaseDir, `${taskId}-REOPEN.json`);
+}
+
+/**
+ * Persist the reopen reason so the next execute-task dispatch can surface it.
+ * A no-op when the reason is empty or the artifact path cannot be resolved —
+ * reopen itself must still succeed even if we cannot attach context.
+ */
+export function writeReopenReason(
+  basePath: string, milestoneId: string, sliceId: string, taskId: string, reason: string,
+): void {
+  const trimmed = reason.trim();
+  if (!trimmed) return;
+  const path = reopenReasonArtifactPath(basePath, milestoneId, sliceId, taskId);
+  if (!path) {
+    logWarning("tool", `reopen-reason: cannot resolve artifact path for ${milestoneId}/${sliceId}/${taskId}; reopen reason not attached to next dispatch`);
+    return;
+  }
+  const artifact: ReopenReasonArtifact = {
+    version: 1,
+    milestoneId, sliceId, taskId,
+    reason: trimmed,
+    createdAt: new Date().toISOString(),
+  };
+  mkdirSync(join(path, ".."), { recursive: true });
+  atomicWriteSync(path, JSON.stringify(artifact, null, 2));
+}
+
+/**
+ * If a reopen reason is pending for this task, claim it (one-shot: the artifact
+ * is deleted on read) and return the markdown block to prepend to the executor's
+ * prompt. Returns null when nothing is pending or the artifact is malformed.
+ */
+export function claimReopenReasonForInjection(
+  basePath: string, milestoneId: string, sliceId: string, taskId: string,
+): { injectionBlock: string } | null {
+  const path = reopenReasonArtifactPath(basePath, milestoneId, sliceId, taskId);
+  if (!path || !existsSync(path)) return null;
+  let art: ReopenReasonArtifact | null = null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial<ReopenReasonArtifact>;
+    if (parsed && parsed.version === 1 && typeof parsed.reason === "string" && parsed.reason.trim()) {
+      art = parsed as ReopenReasonArtifact;
+    }
+  } catch {
+    art = null;
+  }
+  // Claim (delete) regardless of validity so a malformed artifact doesn't
+  // wedge every future dispatch of this task.
+  try { unlinkSync(path); } catch { /* already gone */ }
+  if (!art) return null;
+  return { injectionBlock: formatReopenReasonBlock(art) };
+}
+
+function formatReopenReasonBlock(art: ReopenReasonArtifact): string {
+  return [
+    `## Reopened — Reason (from ${art.taskId})`,
+    "",
+    "This task was previously marked complete but a downstream gate (e.g. complete-slice's full-suite run) reopened it. The verify command in your task plan passed in isolation — it did **not** catch the regression below. Do **not** call `gsd_task_complete` until you have reproduced and fixed exactly what this diagnosis describes, then re-run the specific failing command it names (not just the original scoped verify).",
+    "",
+    "**Diagnosis / fix instructions from the gate:**",
+    "",
+    art.reason.trim(),
+  ].join("\n");
+}

package/src/resources/extensions/gsd/session-status-io.ts

@@ -48,6 +48,11 @@ const PARALLEL_DIR = "parallel";
 const STATUS_SUFFIX = ".status.json";
 const SIGNAL_SUFFIX = ".signal.json";
 const DEFAULT_STALE_TIMEOUT_MS = 30_000;
+// How long a paused worker waits for the coordinator to lift the pause before
+// it degrades to in-process serialization (#1273). Kept below the stale
+// timeout so the wait never races the coordinator's liveness detection.
+const DEFAULT_RESUME_WAIT_MS = 10_000;
+const DEFAULT_RESUME_POLL_MS = 250;
 
 function isSessionStatus(data: unknown): data is SessionStatus {
   return data !== null && typeof data === "object" && "milestoneId" in data && "pid" in data;
@@ -143,6 +148,35 @@ export function consumeSignal(basePath: string, milestoneId: string): SignalMess
   return msg;
 }
 
+/**
+ * Wait for a coordinator to lift a `pause` on a worker by sending `resume`
+ * (or `stop`). Polls the signal file until one of those arrives or the timeout
+ * elapses. Intervening `pause`/`rebase` signals are consumed and ignored so a
+ * repeated pause doesn't reset the wait.
+ *
+ * A worker's `pause` is only ever lifted by the interactive/dashboard resumer;
+ * unattended `gsd headless auto` owns no resumer, so callers use the `"timeout"`
+ * result to degrade to in-process serialization instead of stranding the worker
+ * at a terminal pause it cannot resume (#1273).
+ */
+export async function awaitWorkerResume(
+  basePath: string,
+  milestoneId: string,
+  opts: { timeoutMs?: number; pollMs?: number } = {},
+): Promise<"resume" | "stop" | "timeout"> {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_RESUME_WAIT_MS;
+  const pollMs = opts.pollMs ?? DEFAULT_RESUME_POLL_MS;
+  const deadline = Date.now() + timeoutMs;
+
+  for (;;) {
+    const msg = consumeSignal(basePath, milestoneId);
+    if (msg?.signal === "resume") return "resume";
+    if (msg?.signal === "stop") return "stop";
+    if (Date.now() >= deadline) return "timeout";
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+}
+
 // ─── Stale Detection ───────────────────────────────────────────────────────
 
 /** Check whether a session is stale (PID dead or heartbeat timed out). */

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

@@ -4,6 +4,8 @@ import assert from "node:assert/strict";
 import {
   prepareBrowserDaemonForUat,
   shouldWarmBrowserDaemonForUat,
+  stopBrowserDaemon,
+  teardownWarmedBrowserDaemons,
 } from "../browser-daemon-auto-prep.ts";
 import { commitBrowserEngineResolution } from "../../browser-tools/engine/selection.ts";
 import { resolveGsdBrowserCliAvailability } from "../../shared/gsd-browser-cli.ts";
@@ -142,3 +144,27 @@ test("prepareBrowserDaemonForUat returns actionable error when daemon start fail
 
   assert.match(error ?? "", /gsd-browser daemon failed to start/i);
 });
+
+test("stopBrowserDaemon reports failure when the gsd-browser CLI is missing", () => {
+  const result = stopBrowserDaemon("/tmp/example-project", {
+    env: { GSD_BROWSER_MCP_COMMAND: "/definitely/missing/gsd-browser" },
+  });
+
+  assert.equal(result.ok, false);
+});
+
+test("teardownWarmedBrowserDaemons is a no-op when nothing was warmed", () => {
+  // A failed warm-up must not register a project root for teardown.
+  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.deepEqual(teardownWarmedBrowserDaemons(), []);
+});