negotium 0.1.37 → 0.1.39

package/dist/runtime/src/platform/playwright/public-runtime.ts

@@ -0,0 +1,45 @@
+export {
+  isBrowserJanitorOwner,
+  selectOrphanBrowserPids,
+} from "./browser-processes";
+export {
+  closeBrowserOwnerTabs,
+  configurePlaywrightManagerHost,
+  ensureBrowserProfile,
+  ensurePlaywright,
+  getPlaywrightCapability,
+  getPlaywrightManagerHost,
+  killAllPlaywright,
+  makeBrowserProfileInstanceKey,
+  makeInstanceKey,
+  onPlaywrightFailure,
+  type PlaywrightChildEnvironmentContext,
+  type PlaywrightFailure,
+  type PlaywrightMaintenanceControl,
+  type PlaywrightManagerHost,
+  type PlaywrightProfileBinding,
+  pinPlaywrightInstance,
+  reapPlaywrightOrphans,
+  resetPlaywrightManagerHost,
+  resolvePlaywrightCapabilityOwner,
+  resolvePlaywrightProfileBinding,
+  resolvePlaywrightTopicBinding,
+  resolveTopicProfileDir,
+  stopPlaywrightInstance,
+  stopPlaywrightProfile,
+  unpinPlaywrightInstance,
+  withPlaywrightInstanceMaintenance,
+  withPlaywrightProfileMaintenance,
+} from "./manager";
+export {
+  browserProcessMatchesExpectedProfile,
+  extractUserDataDirArg,
+  selectIdleEvictionKey,
+  selectReusablePort,
+  waitForChildProcessExit,
+  waitForChildProcessSpawnError,
+} from "./manager-utils";
+export {
+  probeMcpTransport,
+  probePlaywrightMcpTransports,
+} from "./transport-probe";

package/dist/runtime/src/platform/playwright/transport-probe.ts

@@ -0,0 +1,89 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { FetchLike, Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { browserOwnerCapability } from "#platform/playwright/capability";
+
+const PROBE_OWNER = "__negotium_transport_probe__";
+const PROBE_TIMEOUT_MS = 3000;
+
+interface ProbeTransportOptions {
+  terminate?: () => Promise<void>;
+  timeoutMs?: number;
+}
+
+export async function probeMcpTransport(
+  transport: Transport,
+  options: ProbeTransportOptions = {},
+): Promise<boolean> {
+  const client = new Client({ name: "negotium-browser-healthcheck", version: "1.0.0" });
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+
+  try {
+    const tools = await Promise.race([
+      (async () => {
+        await client.connect(transport);
+        const result = await client.listTools();
+        if (result.tools.length === 0) throw new Error("browser MCP returned no tools");
+        await options.terminate?.();
+        return result.tools;
+      })(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error("browser MCP transport probe timed out")),
+          options.timeoutMs ?? PROBE_TIMEOUT_MS,
+        );
+        timeout.unref?.();
+      }),
+    ]);
+    return tools.length > 0;
+  } catch {
+    return false;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    try {
+      await client.close();
+    } catch {
+      // The probe already failed; close is best-effort for partially opened transports.
+    }
+  }
+}
+
+/**
+ * Exercise both authenticated transports used by browser-enabled agents.
+ * A process-only response or partial SSE handshake is insufficient: each
+ * transport must initialize, complete tools/list, and close cleanly.
+ */
+export async function probePlaywrightMcpTransports(
+  port: number,
+  capability: string,
+  fetchImpl: FetchLike = fetch as FetchLike,
+): Promise<boolean> {
+  const query = new URLSearchParams({ owner: PROBE_OWNER });
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const ownerCapability = browserOwnerCapability(capability, PROBE_OWNER);
+  const capabilityHeaders = { "X-Browser-Capability": ownerCapability };
+  const authenticatedFetch: FetchLike = (input, init) => {
+    const headers = new Headers(init?.headers);
+    headers.set("X-Browser-Capability", ownerCapability);
+    return fetchImpl(input, { ...init, headers });
+  };
+
+  const sseTransport = new SSEClientTransport(new URL(`${baseUrl}/sse?${query}`), {
+    fetch: authenticatedFetch,
+    eventSourceInit: { fetch: authenticatedFetch },
+    requestInit: { headers: capabilityHeaders },
+  });
+  if (!(await probeMcpTransport(sseTransport))) return false;
+
+  const streamableTransport = new StreamableHTTPClientTransport(
+    new URL(`${baseUrl}/mcp?${query}`),
+    {
+      fetch: authenticatedFetch,
+      requestInit: { headers: capabilityHeaders },
+    },
+  );
+  return probeMcpTransport(streamableTransport, {
+    terminate: () => streamableTransport.terminateSession(),
+  });
+}

package/dist/runtime/src/prompts/builders.ts

@@ -175,6 +175,44 @@ export interface SessionSystemPromptOpts {
   fileDeliveryTools?: boolean;
 }
 
+export type SessionPromptKind = "topic" | "channel" | "manager";
+export type PromptSectionSlot =
+  | "after-runtime-tools"
+  | "after-shared-tasks"
+  | "before-session-communication"
+  | "after-session-communication"
+  | "before-topic-configuration"
+  | "after-topic-configuration"
+  | "after-system-prompt";
+
+export interface PromptSectionContext extends SessionSystemPromptOpts {
+  sessionKind: SessionPromptKind;
+}
+
+export interface PromptExtraSection {
+  id: string;
+  slot: PromptSectionSlot;
+  order?: number;
+  render(context: PromptSectionContext): string | null | undefined;
+}
+
+export interface PromptTemplateRequest {
+  kind: "topic-system" | "channel-system" | "manager-system" | "visual-design";
+  filename: string;
+  fallback: string;
+}
+
+export interface PromptBuilderHost {
+  readonly loadTemplate?: (request: PromptTemplateRequest) => string | null | undefined;
+  readonly extraSections?: readonly PromptExtraSection[];
+}
+
+export interface PromptBuilders {
+  buildTopicSystemPrompt(opts: SessionSystemPromptOpts): string;
+  buildChannelSystemPrompt(opts: SessionSystemPromptOpts): string;
+  buildManagerSystemPrompt(opts: SessionSystemPromptOpts): string;
+}
+
 interface RuntimeToolSectionOpts {
   agentKind: AgentKind;
   canSpawnSubagents?: boolean;
@@ -187,7 +225,15 @@ interface RuntimeToolSectionOpts {
   subagentReportMode?: SubagentReportMode;
 }
 
-function buildRuntimeToolSection(opts: RuntimeToolSectionOpts): string {
+interface RuntimeToolSectionExtensions {
+  render(slot: PromptSectionSlot): string[];
+  visualDesignGuide: string;
+}
+
+function buildRuntimeToolSection(
+  opts: RuntimeToolSectionOpts,
+  extensions: RuntimeToolSectionExtensions,
+): string {
   const {
     agentKind,
     canSpawnSubagents = false,
@@ -282,13 +328,16 @@ function buildRuntimeToolSection(opts: RuntimeToolSectionOpts): string {
           'Do not use provider built-in "AskUserQuestion"; it is disabled or unsupported in this headless chat runtime. Use the runtime ask_user_question tool instead.',
         ]),
     scheduleSelfToolLine,
-    ...(visualTools ? ["", visualDesignGuide()] : []),
+    ...(visualTools && extensions.visualDesignGuide ? ["", extensions.visualDesignGuide] : []),
+    ...extensions.render("after-runtime-tools"),
     "",
     "## Shared Tasks",
     taskToolLine,
     "Use this shared task store for plans, task progress, and checklist updates. It is visible across claude/codex/maestro turns and drives the live task panel.",
     nativeTaskPolicyLine,
+    ...extensions.render("after-shared-tasks"),
     ...fileDeliverySection,
+    ...extensions.render("before-session-communication"),
     "",
     "## Session Communication",
     ...(subagentParentTitle
@@ -313,6 +362,7 @@ function buildRuntimeToolSection(opts: RuntimeToolSectionOpts): string {
       : []),
     "Do not use session communication to make another topic perform destructive changes without the user's clear intent.",
     ...spawnSubagentSection,
+    ...extensions.render("after-session-communication"),
   ];
 
   const modelCatalog = SELECTABLE_MODELS.map(
@@ -343,69 +393,160 @@ function buildRuntimeToolSection(opts: RuntimeToolSectionOpts): string {
   if (agentKind !== "claude") {
     return [
       ...shared,
+      ...extensions.render("before-topic-configuration"),
       ...topicConfig,
+      ...extensions.render("after-topic-configuration"),
       "",
       "## Runtime Tool Limits",
       "If file delivery or topic configuration tools are not present in your available tools for this session, do not claim you used them. Tell the user this session does not expose that in-chat tool action.",
     ].join("\n");
   }
 
-  return [...shared, ...topicConfig].join("\n");
+  return [
+    ...shared,
+    ...extensions.render("before-topic-configuration"),
+    ...topicConfig,
+    ...extensions.render("after-topic-configuration"),
+  ].join("\n");
 }
 
-export function buildTopicSystemPrompt(opts: SessionSystemPromptOpts): string {
-  const uploadsDir = `${opts.workspaceCwd}/attachments`;
-  let prompt =
-    replaceVars(topicSystemPromptTemplate(), {
-      AI_LABEL: opts.aiLabel,
-      TOPIC_TITLE: opts.topicTitle,
-      WORKSPACE_CWD: opts.workspaceCwd,
-      UPLOADS_DIR: uploadsDir,
-    }) +
-    buildRuntimeToolSection({
-      agentKind: opts.agentKind,
-      canSpawnSubagents: opts.canSpawnSubagents,
-      canStageSubagents: opts.canStageSubagents,
-      visualTools: opts.visualTools,
-      fileDeliveryTools: opts.fileDeliveryTools,
-      currentModel: opts.currentModel,
-      currentEffort: opts.currentEffort,
-      subagentParentTitle: opts.subagentParentTitle,
-      subagentReportMode: opts.subagentReportMode,
-    });
-  if (opts.description?.trim()) {
-    prompt += `\n\n## Topic-Specific Instructions\n${opts.description.trim()}`;
+export function createPromptBuilders(host: PromptBuilderHost = {}): PromptBuilders {
+  const loadTemplate = host.loadTemplate;
+  const sections = (host.extraSections ?? []).map((section): PromptExtraSection => {
+    const render = section.render;
+    const snapshot: PromptExtraSection = {
+      id: section.id,
+      slot: section.slot,
+      ...(section.order === undefined ? {} : { order: section.order }),
+      render(context) {
+        return render.call(snapshot, context);
+      },
+    };
+    return Object.freeze(snapshot);
+  });
+  const ids = new Set<string>();
+  for (const section of sections) {
+    if (!section.id.trim()) throw new Error("prompt extra section id is required");
+    if (ids.has(section.id)) throw new Error(`duplicate prompt extra section id: ${section.id}`);
+    ids.add(section.id);
   }
-  return prompt;
-}
+  sections.sort((a, b) => (a.order ?? 0) - (b.order ?? 0) || a.id.localeCompare(b.id));
+
+  const templateCache = new Map<PromptTemplateRequest["kind"], string>();
+  const template = (request: PromptTemplateRequest): string => {
+    const cached = templateCache.get(request.kind);
+    if (cached !== undefined) return cached;
+    const loaded = loadTemplate?.(request);
+    const value =
+      loaded ??
+      (request.kind === "topic-system"
+        ? topicSystemPromptTemplate()
+        : request.kind === "channel-system"
+          ? channelSystemPromptTemplate()
+          : request.kind === "manager-system"
+            ? managerSystemPromptTemplate()
+            : visualDesignGuide());
+    templateCache.set(request.kind, value);
+    return value;
+  };
 
-export function buildChannelSystemPrompt(opts: SessionSystemPromptOpts): string {
-  const uploadsDir = `${opts.workspaceCwd}/attachments`;
-  return (
-    replaceVars(channelSystemPromptTemplate(), {
-      AI_LABEL: opts.aiLabel,
-      TOPIC_TITLE: opts.topicTitle,
-      WORKSPACE_CWD: opts.workspaceCwd,
-      UPLOADS_DIR: uploadsDir,
-    }) +
-    buildRuntimeToolSection({
-      agentKind: opts.agentKind,
-      canSpawnSubagents: false,
-      canStageSubagents: false,
-      visualTools: opts.visualTools,
-      fileDeliveryTools: opts.fileDeliveryTools,
-      currentModel: opts.currentModel,
-      currentEffort: opts.currentEffort,
-      subagentParentTitle: opts.subagentParentTitle,
-      subagentReportMode: opts.subagentReportMode,
-    })
-  );
-}
+  const build = (
+    sessionKind: SessionPromptKind,
+    opts: SessionSystemPromptOpts,
+    sessionTemplate: string,
+  ): string => {
+    const context = Object.freeze({ ...opts, sessionKind });
+    const render = (slot: PromptSectionSlot): string[] =>
+      sections
+        .filter((section) => section.slot === slot)
+        .map((section) => section.render(context)?.trim())
+        .filter((section): section is string => Boolean(section))
+        .flatMap((section) => ["", section]);
+    const uploadsDir = `${opts.workspaceCwd}/attachments`;
+    let prompt =
+      replaceVars(sessionTemplate, {
+        AI_LABEL: opts.aiLabel,
+        TOPIC_TITLE: opts.topicTitle,
+        WORKSPACE_CWD: opts.workspaceCwd,
+        UPLOADS_DIR: uploadsDir,
+      }) +
+      buildRuntimeToolSection(
+        {
+          agentKind: opts.agentKind,
+          canSpawnSubagents: sessionKind === "channel" ? false : opts.canSpawnSubagents,
+          canStageSubagents: sessionKind === "channel" ? false : opts.canStageSubagents,
+          visualTools: opts.visualTools,
+          fileDeliveryTools: opts.fileDeliveryTools,
+          currentModel: opts.currentModel,
+          currentEffort: opts.currentEffort,
+          subagentParentTitle: opts.subagentParentTitle,
+          subagentReportMode: opts.subagentReportMode,
+        },
+        {
+          render,
+          visualDesignGuide: template({
+            kind: "visual-design",
+            filename: "visual-design.md",
+            fallback: "",
+          }),
+        },
+      );
+    if (sessionKind !== "channel" && opts.description?.trim()) {
+      prompt += `\n\n## Topic-Specific Instructions\n${opts.description.trim()}`;
+    }
+    if (sessionKind === "manager") {
+      prompt += `\n\n${template({
+        kind: "manager-system",
+        filename: "manager-system.md",
+        fallback: FALLBACK_MANAGER_SYSTEM_PROMPT_TEMPLATE,
+      })}`;
+    }
+    return `${prompt}${render("after-system-prompt").join("\n")}`;
+  };
 
-export function buildManagerSystemPrompt(opts: SessionSystemPromptOpts): string {
-  return `${buildTopicSystemPrompt(opts)}\n\n${managerSystemPromptTemplate()}`;
+  return Object.freeze({
+    buildTopicSystemPrompt(opts: SessionSystemPromptOpts) {
+      return build(
+        "topic",
+        opts,
+        template({
+          kind: "topic-system",
+          filename: "topic-system.md",
+          fallback: FALLBACK_TOPIC_SYSTEM_PROMPT_TEMPLATE,
+        }),
+      );
+    },
+    buildChannelSystemPrompt(opts: SessionSystemPromptOpts) {
+      return build(
+        "channel",
+        opts,
+        template({
+          kind: "channel-system",
+          filename: "channel-system.md",
+          fallback: FALLBACK_CHANNEL_SYSTEM_PROMPT_TEMPLATE,
+        }),
+      );
+    },
+    buildManagerSystemPrompt(opts: SessionSystemPromptOpts) {
+      return build(
+        "manager",
+        opts,
+        template({
+          kind: "topic-system",
+          filename: "topic-system.md",
+          fallback: FALLBACK_TOPIC_SYSTEM_PROMPT_TEMPLATE,
+        }),
+      );
+    },
+  });
 }
 
+const defaultPromptBuilders = createPromptBuilders();
+
+export const buildTopicSystemPrompt = defaultPromptBuilders.buildTopicSystemPrompt;
+export const buildChannelSystemPrompt = defaultPromptBuilders.buildChannelSystemPrompt;
+export const buildManagerSystemPrompt = defaultPromptBuilders.buildManagerSystemPrompt;
+
 export function buildMemoryPromptSection(opts: {
   briefFile: string;
   wikiDir: string;

package/dist/runtime/src/query/active-rooms.ts

@@ -119,6 +119,8 @@ export interface RoomQueryControl {
   sessionId?: string | null;
   abortController: AbortController;
   abortReason: AbortReason;
+  /** Specific failure surfaced when infrastructure aborts the turn. */
+  abortError?: string;
   /** Epoch ms when this turn claimed the room (stale-abort guard). */
   startedAt?: number;
   /**

package/dist/runtime/src/query/public-runtime.ts

@@ -17,6 +17,14 @@ export {
   type RoomQueryRegistryHost,
   type RuntimeTurnLeaseLike,
 } from "./room-query-registry";
+export {
+  clearQueryState,
+  createQueryStateStore,
+  type QueryStateStore,
+  type QueryStateStoreLogger,
+  type QueryStateStoreOptions,
+  writeQueryState,
+} from "./state";
 export {
   AbortReason,
   type HandleAgentQueryOutcome,

package/dist/runtime/src/query/state.ts

@@ -7,38 +7,86 @@ import type { QueryState } from "#types";
 
 type QueryStateUserId = number | string;
 
-function queryStateDirPath(userId: QueryStateUserId): string {
-  return join(USERS_LOG_DIR, String(userId), "active-queries");
+export interface QueryStateStoreLogger {
+  warn(context: Record<string, unknown>, message: string): void;
 }
 
-function queryStateFile(userId: QueryStateUserId, topicId: string): string {
-  return join(queryStateDirPath(userId), `${sanitizeId(topicId)}.json`);
+export interface QueryStateStoreOptions {
+  usersLogDir: string;
+  logger?: QueryStateStoreLogger;
+  sanitizeTopicId?: (topicId: string) => string;
 }
 
-function legacyQueryStateFile(
-  userId: QueryStateUserId,
-  topicName: string | undefined,
-): string | null {
-  if (!topicName || topicName === "." || topicName === ".." || basename(topicName) !== topicName) {
-    return null;
-  }
-  return join(queryStateDirPath(userId), `${topicName}.json`);
+export interface QueryStateStore {
+  write(userId: QueryStateUserId, topicId: string, topicName: string, task?: string): void;
+  clear(userId: QueryStateUserId, topicId: string, legacyTopicName?: string): void;
 }
 
+export function createQueryStateStore(options: QueryStateStoreOptions): QueryStateStore {
+  const sanitize = options.sanitizeTopicId ?? sanitizeId;
+  const queryStateDirPath = (userId: QueryStateUserId): string =>
+    join(options.usersLogDir, String(userId), "active-queries");
+  const queryStateFile = (userId: QueryStateUserId, topicId: string): string =>
+    join(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
+  const legacyQueryStateFile = (
+    userId: QueryStateUserId,
+    topicName: string | undefined,
+  ): string | null => {
+    if (
+      !topicName ||
+      topicName === "." ||
+      topicName === ".." ||
+      basename(topicName) !== topicName
+    ) {
+      return null;
+    }
+    return join(queryStateDirPath(userId), `${topicName}.json`);
+  };
+
+  return {
+    write(userId, topicId, topicName, task) {
+      const dir = queryStateDirPath(userId);
+      mkdirSync(dir, { recursive: true });
+      const state: QueryState = { topicId, topicName, since: new Date().toISOString() };
+      if (task) state.task = [...task.replace(/\n+/g, " ").trim()].slice(0, 100).join("");
+      const target = queryStateFile(userId, topicId);
+      const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tmp, JSON.stringify(state));
+      renameSync(tmp, target);
+    },
+    clear(userId, topicId, legacyTopicName) {
+      const paths = [
+        queryStateFile(userId, topicId),
+        legacyQueryStateFile(userId, legacyTopicName),
+      ].filter((path): path is string => Boolean(path));
+      for (const path of new Set(paths)) {
+        try {
+          unlinkSync(path);
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException)?.code !== "ENOENT") {
+            options.logger?.warn(
+              { err: error, userId, topicId, path },
+              "Failed to clear query state file",
+            );
+          }
+        }
+      }
+    },
+  };
+}
+
+const defaultQueryStateStore = createQueryStateStore({
+  usersLogDir: USERS_LOG_DIR,
+  logger,
+});
+
 export function writeQueryState(
   userId: QueryStateUserId,
   topicId: string,
   topicName: string,
   task?: string,
 ) {
-  const dir = queryStateDirPath(userId);
-  mkdirSync(dir, { recursive: true });
-  const state: QueryState = { topicId, topicName, since: new Date().toISOString() };
-  if (task) state.task = [...task.replace(/\n+/g, " ").trim()].slice(0, 100).join("");
-  const target = queryStateFile(userId, topicId);
-  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(tmp, JSON.stringify(state));
-  renameSync(tmp, target);
+  defaultQueryStateStore.write(userId, topicId, topicName, task);
 }
 
 export function clearQueryState(
@@ -46,17 +94,5 @@ export function clearQueryState(
   topicId: string,
   legacyTopicName?: string,
 ) {
-  const paths = [
-    queryStateFile(userId, topicId),
-    legacyQueryStateFile(userId, legacyTopicName),
-  ].filter((path): path is string => Boolean(path));
-  for (const path of new Set(paths)) {
-    try {
-      unlinkSync(path);
-    } catch (e) {
-      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
-        logger.warn({ err: e, userId, topicId, path }, "Failed to clear query state file");
-      }
-    }
-  }
+  defaultQueryStateStore.clear(userId, topicId, legacyTopicName);
 }

package/dist/runtime/src/query/types.ts

@@ -80,4 +80,5 @@ export enum AbortReason {
   None = "none",
   Internal = "internal", // replaced by a newer query on the same topic
   External = "external", // /abort command or abort_session via session-inbox
+  Infrastructure = "infrastructure", // required runtime dependency exited unexpectedly
 }

package/dist/runtime/src/runtime/playwright-turn-abort.ts

@@ -0,0 +1,59 @@
+import { logger } from "#platform/logger";
+import { onPlaywrightFailure, type PlaywrightFailure } from "#platform/playwright/manager";
+import { AbortReason } from "#query/types";
+
+export interface PlaywrightTurnControl {
+  topicId: string;
+  queryId: string;
+  abortController: AbortController;
+  abortReason: AbortReason;
+  abortError?: string;
+}
+
+const turnsByInstance = new Map<string, Set<PlaywrightTurnControl>>();
+
+export function trackPlaywrightTurn(instanceKey: string, control: PlaywrightTurnControl): void {
+  const turns = turnsByInstance.get(instanceKey) ?? new Set<PlaywrightTurnControl>();
+  turns.add(control);
+  turnsByInstance.set(instanceKey, turns);
+}
+
+export function untrackPlaywrightTurn(instanceKey: string, control: PlaywrightTurnControl): void {
+  const turns = turnsByInstance.get(instanceKey);
+  if (!turns) return;
+  turns.delete(control);
+  if (turns.size === 0) turnsByInstance.delete(instanceKey);
+}
+
+function failureMessage(failure: PlaywrightFailure): string {
+  if (failure.reason === "unhealthy") {
+    return "Browser MCP transport became unresponsive and was restarted";
+  }
+  if (failure.reason === "process-error") {
+    return `Browser MCP process failed${failure.error ? `: ${failure.error}` : ""}`;
+  }
+  return (
+    "Browser MCP exited unexpectedly" +
+    (failure.code === null || failure.code === undefined ? "" : ` (exitCode=${failure.code})`)
+  );
+}
+
+export function abortPlaywrightTurns(instanceKey: string, failure: PlaywrightFailure): number {
+  const turns = turnsByInstance.get(instanceKey);
+  if (!turns) return 0;
+
+  const error = failureMessage(failure);
+  let aborted = 0;
+  for (const control of turns) {
+    if (control.abortController.signal.aborted) continue;
+    control.abortReason = AbortReason.Infrastructure;
+    control.abortError = error;
+    control.abortController.abort(new Error(error));
+    aborted++;
+  }
+  turnsByInstance.delete(instanceKey);
+  logger.warn({ instanceKey, failure, aborted }, "Aborted turns after browser MCP failure");
+  return aborted;
+}
+
+onPlaywrightFailure(abortPlaywrightTurns);