negotium 0.1.37 → 0.1.39

package/dist/runtime/src/agents/topic-cleanup.ts

@@ -18,13 +18,18 @@ import { SUPPORTED_AGENTS } from "#agents/index";
 import { getRegistry } from "#agents/registry";
 import { logger } from "#platform/logger";
 import {
-  type ConversationEntry,
   getActiveConversationPath,
   getConversationPath,
   readConversation,
   readRawConversation,
 } from "#storage/conversations";
-import type { AgentKind } from "#types";
+import type { AgentKind, UnifiedEvent } from "#types";
+
+export interface TopicConversationEntry {
+  ts: string;
+  agent: AgentKind;
+  event: UnifiedEvent;
+}
 
 export interface PurgeSessionRef {
   agent: AgentKind;
@@ -37,7 +42,7 @@ export interface PurgeSessionRef {
  * switch back), so we collect into a Set to deduplicate before deletion.
  */
 function collectSessionIdsByAgent(
-  entries: ConversationEntry[],
+  entries: TopicConversationEntry[],
   extraSessions: PurgeSessionRef[] = [],
 ): Map<AgentKind, Set<string>> {
   const out = new Map<AgentKind, Set<string>>();
@@ -77,25 +82,49 @@ export interface PurgeTopicLogsOptions {
   extraSessions?: PurgeSessionRef[];
 }
 
+export interface TopicLogMaintenanceHost {
+  readonly agents: readonly AgentKind[];
+  readonly readActiveConversation: (
+    userId: number | string,
+    topicName: string,
+  ) => TopicConversationEntry[];
+  readonly readRawConversation: (
+    userId: number | string,
+    topicName: string,
+  ) => TopicConversationEntry[];
+  readonly activeConversationPath: (userId: number | string, topicName: string) => string;
+  readonly rawConversationPath: (userId: number | string, topicName: string) => string;
+  readonly cleanupRollouts: (agent: AgentKind, cwd: string, sessionIds: string[]) => Promise<void>;
+  readonly warn: (context: Record<string, unknown>, message: string) => void;
+}
+
+export interface TopicLogMaintenance {
+  cleanupTopicRollouts(opts: PurgeTopicLogsOptions): Promise<boolean>;
+  cleanupTopicRolloutsFromEntries(
+    opts: PurgeTopicLogsOptions,
+    entries: TopicConversationEntry[],
+  ): Promise<boolean>;
+  rotateTopicLogs(opts: RotateTopicLogsOptions): Promise<RotateTopicLogsResult>;
+  purgeTopicLogs(opts: PurgeTopicLogsOptions): Promise<boolean>;
+}
+
 async function cleanupSessionRollouts(
+  host: TopicLogMaintenanceHost,
   opts: PurgeTopicLogsOptions,
-  entries: ConversationEntry[],
+  entries: TopicConversationEntry[],
 ): Promise<boolean> {
   const { userId, topicName, cwd, extraSessions = [] } = opts;
   const idsByAgent = collectSessionIdsByAgent(entries, extraSessions);
   let cleanupFailed = false;
 
   await Promise.all(
-    SUPPORTED_AGENTS.map(async (agent) => {
+    host.agents.map(async (agent) => {
       const ids = idsByAgent.get(agent);
       if (!ids || ids.size === 0) return;
       try {
-        await getRegistry(agent).cleanupRollouts({
-          cwd,
-          sessionIds: Array.from(ids),
-        });
+        await host.cleanupRollouts(agent, cwd, Array.from(ids));
       } catch (e) {
-        logger.warn(
+        host.warn(
           { err: e, userId, topicName, agent, count: ids.size },
           "topic logs: agent cleanup failed",
         );
@@ -107,19 +136,6 @@ async function cleanupSessionRollouts(
   return !cleanupFailed;
 }
 
-/** Remove every provider rollout currently manifested by a topic log. */
-export async function cleanupTopicRollouts(opts: PurgeTopicLogsOptions): Promise<boolean> {
-  return cleanupSessionRollouts(opts, readRawConversation(opts.userId, opts.topicName));
-}
-
-/** Remove rollout ids captured from a point-in-time conversation manifest. */
-export async function cleanupTopicRolloutsFromEntries(
-  opts: PurgeTopicLogsOptions,
-  entries: ConversationEntry[],
-): Promise<boolean> {
-  return cleanupSessionRollouts(opts, entries);
-}
-
 export interface RotateTopicLogsOptions extends PurgeTopicLogsOptions {
   /** Number of complete user turns carried into the replacement session. */
   retainTurns: number;
@@ -132,116 +148,138 @@ export interface RotateTopicLogsResult {
   retainedEntries: number;
 }
 
-/**
- * Replace a topic's native provider sessions while retaining a bounded tail
- * of its provider-neutral conversation log. This is used by long-lived Cron
- * topics: a fresh native rollout keeps prompt/session state bounded, and the
- * retained tail gives the next rollout enough context to continue naturally.
- */
-export async function rotateTopicLogs(
-  opts: RotateTopicLogsOptions,
-): Promise<RotateTopicLogsResult> {
-  const retainTurns = Math.max(0, Math.floor(opts.retainTurns));
-  const entries = readConversation(opts.userId, opts.topicName);
-  const userEntryIndexes = entries.flatMap((entry, index) =>
-    entry.event.type === "user_message" ? [index] : [],
-  );
-  const totalTurns = userEntryIndexes.length;
-  const firstRetainedIndex =
-    retainTurns === 0
-      ? entries.length
-      : (userEntryIndexes[Math.max(0, totalTurns - retainTurns)] ?? 0);
-  // Native session ids point at rollouts that are removed below. Keeping
-  // those manifest entries would make later cleanup treat deleted files as
-  // live context, so only conversational events cross the rotation boundary.
-  const retained = entries
-    .slice(firstRetainedIndex)
-    .filter((entry) => entry.event.type !== "session");
-
-  if (!(await cleanupSessionRollouts(opts, entries))) {
-    logger.warn(
-      { userId: opts.userId, topicName: opts.topicName },
-      "rotateTopicLogs: keeping current context because rollout cleanup failed",
-    );
-    return {
-      rotated: false,
-      totalTurns,
-      retainedTurns: Math.min(totalTurns, retainTurns),
-      retainedEntries: retained.length,
-    };
-  }
+export function createTopicLogMaintenance(host: TopicLogMaintenanceHost): TopicLogMaintenance {
+  const runtimeHost: TopicLogMaintenanceHost = Object.freeze({
+    ...host,
+    agents: Object.freeze([...host.agents]),
+  });
+  const cleanupFromEntries = (
+    opts: PurgeTopicLogsOptions,
+    entries: TopicConversationEntry[],
+  ): Promise<boolean> => cleanupSessionRollouts(runtimeHost, opts, entries);
 
-  const path = getActiveConversationPath(opts.userId, opts.topicName);
-  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(
-      tempPath,
-      retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join("\n")}\n` : "",
-      { flag: "wx" },
-    );
-    renameSync(tempPath, path);
-  } catch (e) {
-    try {
-      unlinkSync(tempPath);
-    } catch {}
-    logger.warn({ err: e, path }, "rotateTopicLogs: conversation replacement failed");
-    return {
-      rotated: false,
-      totalTurns,
-      retainedTurns: Math.min(totalTurns, retainTurns),
-      retainedEntries: retained.length,
-    };
-  }
+  return Object.freeze({
+    cleanupTopicRollouts(opts: PurgeTopicLogsOptions) {
+      return cleanupFromEntries(opts, runtimeHost.readRawConversation(opts.userId, opts.topicName));
+    },
+    cleanupTopicRolloutsFromEntries: cleanupFromEntries,
+    async rotateTopicLogs(opts: RotateTopicLogsOptions) {
+      const retainTurns = Math.max(0, Math.floor(opts.retainTurns));
+      const entries = runtimeHost.readActiveConversation(opts.userId, opts.topicName);
+      const userEntryIndexes = entries.flatMap((entry, index) =>
+        entry.event.type === "user_message" ? [index] : [],
+      );
+      const totalTurns = userEntryIndexes.length;
+      const firstRetainedIndex =
+        retainTurns === 0
+          ? entries.length
+          : (userEntryIndexes[Math.max(0, totalTurns - retainTurns)] ?? 0);
+      const retained = entries
+        .slice(firstRetainedIndex)
+        .filter((entry) => entry.event.type !== "session");
+
+      if (!(await cleanupFromEntries(opts, entries))) {
+        runtimeHost.warn(
+          { userId: opts.userId, topicName: opts.topicName },
+          "rotateTopicLogs: keeping current context because rollout cleanup failed",
+        );
+        return {
+          rotated: false,
+          totalTurns,
+          retainedTurns: Math.min(totalTurns, retainTurns),
+          retainedEntries: retained.length,
+        };
+      }
+
+      const path = runtimeHost.activeConversationPath(opts.userId, opts.topicName);
+      const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+      try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(
+          tempPath,
+          retained.length > 0
+            ? `${retained.map((entry) => JSON.stringify(entry)).join("\n")}\n`
+            : "",
+          { flag: "wx" },
+        );
+        renameSync(tempPath, path);
+      } catch (e) {
+        try {
+          unlinkSync(tempPath);
+        } catch {}
+        runtimeHost.warn({ err: e, path }, "rotateTopicLogs: conversation replacement failed");
+        return {
+          rotated: false,
+          totalTurns,
+          retainedTurns: Math.min(totalTurns, retainTurns),
+          retainedEntries: retained.length,
+        };
+      }
+
+      return {
+        rotated: true,
+        totalTurns,
+        retainedTurns: Math.min(totalTurns, retainTurns),
+        retainedEntries: retained.length,
+      };
+    },
+    async purgeTopicLogs(opts: PurgeTopicLogsOptions) {
+      const { userId, topicName } = opts;
+      const entries = runtimeHost.readRawConversation(userId, topicName);
+      if (!(await cleanupFromEntries(opts, entries))) {
+        runtimeHost.warn(
+          { userId, topicName },
+          "purgeTopicLogs: keeping unified log because one or more rollout cleanups failed",
+        );
+        return false;
+      }
 
-  return {
-    rotated: true,
-    totalTurns,
-    retainedTurns: Math.min(totalTurns, retainTurns),
-    retainedEntries: retained.length,
-  };
+      let unlinkFailed = false;
+      for (const path of [
+        runtimeHost.activeConversationPath(userId, topicName),
+        runtimeHost.rawConversationPath(userId, topicName),
+      ]) {
+        try {
+          unlinkSync(path);
+        } catch (e) {
+          if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
+            runtimeHost.warn({ err: e, path }, "purgeTopicLogs: conversation log unlink failed");
+            unlinkFailed = true;
+          }
+        }
+      }
+      return !unlinkFailed;
+    },
+  });
 }
 
+const defaultTopicLogMaintenance = createTopicLogMaintenance({
+  agents: SUPPORTED_AGENTS,
+  readActiveConversation: readConversation,
+  readRawConversation,
+  activeConversationPath: getActiveConversationPath,
+  rawConversationPath: getConversationPath,
+  async cleanupRollouts(agent, cwd, sessionIds) {
+    await getRegistry(agent).cleanupRollouts({ cwd, sessionIds });
+  },
+  warn: logger.warn.bind(logger),
+});
+
+/** Remove every provider rollout currently manifested by a topic log. */
+export const cleanupTopicRollouts = defaultTopicLogMaintenance.cleanupTopicRollouts;
+
+/** Remove rollout ids captured from a point-in-time conversation manifest. */
+export const cleanupTopicRolloutsFromEntries =
+  defaultTopicLogMaintenance.cleanupTopicRolloutsFromEntries;
+
 /**
- * Best-effort teardown of every artifact associated with a topic's
- * conversation lifecycle. Order matters and is intentional:
- *
- *   1. Read the unified log first — it's the authoritative manifest of
- *      every SDK session id the topic has emitted. Merge any DB session id
- *      passed via `extraSessions` for synthetic rollouts not yet emitted.
- *   2. Dispatch per-agent rollout cleanup in parallel (independent
- *      filesystems, no shared state).
- *   3. Unlink the unified log LAST so a partial rollout-cleanup failure
- *      leaves the manifest in place for a future retry.
- *
- * Errors at every step are logged and reported through the return value.
- * Callers must not commit a reset/delete state transition when this returns
- * false, because the retained manifest can otherwise resurrect old context.
+ * Replace a topic's native provider sessions while retaining a bounded tail
+ * of its provider-neutral conversation log.
  */
-export async function purgeTopicLogs(opts: PurgeTopicLogsOptions): Promise<boolean> {
-  const { userId, topicName } = opts;
-  const entries = readRawConversation(userId, topicName);
-  if (!(await cleanupSessionRollouts(opts, entries))) {
-    logger.warn(
-      { userId, topicName },
-      "purgeTopicLogs: keeping unified log because one or more rollout cleanups failed",
-    );
-    return false;
-  }
+export const rotateTopicLogs = defaultTopicLogMaintenance.rotateTopicLogs;
 
-  let unlinkFailed = false;
-  for (const path of [
-    getActiveConversationPath(userId, topicName),
-    getConversationPath(userId, topicName),
-  ]) {
-    try {
-      unlinkSync(path);
-    } catch (e) {
-      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
-        logger.warn({ err: e, path }, "purgeTopicLogs: conversation log unlink failed");
-        unlinkFailed = true;
-      }
-    }
-  }
-  return !unlinkFailed;
-}
+/**
+ * Best-effort teardown of every artifact associated with a topic's
+ * conversation lifecycle.
+ */
+export const purgeTopicLogs = defaultTopicLogMaintenance.purgeTopicLogs;

package/dist/runtime/src/index.ts

@@ -197,7 +197,10 @@ export {
   runNodeRequestHandlers,
   unregisterNodeRequestHandler,
 } from "#platform/node-plugins";
-export { killAllPlaywright } from "#platform/playwright/manager";
+export {
+  killAllPlaywright,
+  reapPlaywrightOrphans as reapOrphanBrowsers,
+} from "#platform/playwright/manager";
 // ── Query control ───────────────────────────────────────────────────
 export {
   abortAllRooms,

package/dist/runtime/src/mcp/factories/index.ts

@@ -3,6 +3,15 @@ export {
   type SessionCommContext,
   type SessionCommContextDefaults,
 } from "../session-comm/context";
+export {
+  createSessionTargetCatalog,
+  type SessionTarget,
+  type SessionTargetCatalog,
+  type SessionTargetCatalogHost,
+  type SessionTopicEntry,
+  type SessionTopicRow,
+  type ValidateSessionTargetResult,
+} from "../session-comm/topic-catalog";
 export { executeVaultHttpRequest } from "../vault-http";
 export { executeVaultRun } from "../vault-run";
 export {

package/dist/runtime/src/mcp/session-comm/topic-catalog.ts

@@ -0,0 +1,132 @@
+export interface SessionTopicRow {
+  id: string;
+  title: string;
+  kind: string | null;
+  agent: string | null;
+  sessionId: string | null;
+  description: string | null;
+}
+
+export interface SessionTopicEntry<TAgent extends string = string> {
+  sessionId: string;
+  messageThreadId: number;
+  name: string;
+  kind: "agent" | "channel";
+  description?: string;
+  topicId?: string;
+  agent?: TAgent;
+}
+
+export interface SessionTarget<TAgent extends string = string> {
+  key: string;
+  topic: SessionTopicEntry<TAgent>;
+}
+
+export type ValidateSessionTargetResult<TAgent extends string = string> =
+  | { ok: true; target: SessionTopicEntry<TAgent> }
+  | {
+      ok: false;
+      error: {
+        content: Array<{ type: "text"; text: string }>;
+        isError: true;
+      };
+    };
+
+export interface SessionTargetCatalogHost<TAgent extends string = string> {
+  readonly listRows: () => SessionTopicRow[];
+  readonly currentTopicId?: string;
+  readonly currentTopicName?: string;
+  readonly isAgent: (value: string | null) => value is TAgent;
+}
+
+export interface SessionTargetCatalog<TAgent extends string = string> {
+  listTargets(): SessionTarget<TAgent>[];
+  getTopics(): Record<string, SessionTopicEntry<TAgent>>;
+  validateTarget(to: string): ValidateSessionTargetResult<TAgent>;
+}
+
+export function createSessionTargetCatalog<TAgent extends string = string>(
+  host: SessionTargetCatalogHost<TAgent>,
+): SessionTargetCatalog<TAgent> {
+  const { currentTopicId, currentTopicName, isAgent, listRows } = host;
+
+  function listTargets(): SessionTarget<TAgent>[] {
+    const eligibleRows = listRows().filter((row) => row.kind !== "manager");
+    const titleCounts = new Map<string, number>();
+    const qualifiedCounts = new Map<string, number>();
+    for (const row of eligibleRows) {
+      const normalized = row.title.toLowerCase();
+      titleCounts.set(normalized, (titleCounts.get(normalized) ?? 0) + 1);
+      const kind = row.kind === "agent" ? "agent" : "channel";
+      const qualified = `${kind}:${normalized}`;
+      qualifiedCounts.set(qualified, (qualifiedCounts.get(qualified) ?? 0) + 1);
+    }
+
+    const rows = eligibleRows.filter((row) =>
+      currentTopicId ? row.id !== currentTopicId : row.title !== currentTopicName,
+    );
+    return rows.map((row) => {
+      const agent = isAgent(row.agent) ? row.agent : undefined;
+      const kind = row.kind === "agent" ? "agent" : "channel";
+      const topic: SessionTopicEntry<TAgent> = {
+        sessionId: row.sessionId ?? "",
+        messageThreadId: 0,
+        name: row.title,
+        kind,
+        topicId: row.id,
+        ...(agent && { agent }),
+        ...(row.description && { description: row.description }),
+      };
+      const collision = (titleCounts.get(row.title.toLowerCase()) ?? 0) > 1;
+      const qualified = `${kind}:${row.title}`;
+      const sameKindCollision =
+        (qualifiedCounts.get(`${kind}:${row.title.toLowerCase()}`) ?? 0) > 1;
+      return {
+        key: sameKindCollision ? `${qualified}:${row.id}` : collision ? qualified : row.title,
+        topic,
+      };
+    });
+  }
+
+  function getTopics(): Record<string, SessionTopicEntry<TAgent>> {
+    const result: Record<string, SessionTopicEntry<TAgent>> = {};
+    const targets = listTargets();
+    const qualifiedCounts = new Map<string, number>();
+    for (const { topic } of targets) {
+      const qualified = `${topic.kind}:${topic.name.toLowerCase()}`;
+      qualifiedCounts.set(qualified, (qualifiedCounts.get(qualified) ?? 0) + 1);
+    }
+    for (const { key, topic } of targets) {
+      const qualified = `${topic.kind}:${topic.name}`;
+      if ((qualifiedCounts.get(qualified.toLowerCase()) ?? 0) === 1) {
+        result[qualified] = topic;
+      }
+      result[key] = topic;
+    }
+    return result;
+  }
+
+  function validateTarget(to: string): ValidateSessionTargetResult<TAgent> {
+    const topics = getTopics();
+    const target = topics[to];
+    if (target) return { ok: true, target };
+
+    const available = listTargets()
+      .filter(({ topic }) => Boolean(topic.agent))
+      .map(({ key }) => key);
+    return {
+      ok: false,
+      error: {
+        content: [
+          {
+            type: "text",
+            text: `Error: Session "${to}" not found.\nAvailable: ${available.join(", ") || "none"}`,
+          },
+        ],
+        isError: true,
+      },
+    };
+  }
+
+  return Object.freeze({ listTargets, getTopics, validateTarget });
+}

package/dist/runtime/src/mcp/session-comm/topics.ts

@@ -22,6 +22,10 @@ import {
   userId,
   withDb,
 } from "./runtime";
+import {
+  type SessionTarget as CatalogSessionTarget,
+  createSessionTargetCatalog,
+} from "./topic-catalog";
 
 export type { QueryState };
 
@@ -39,10 +43,7 @@ export interface TopicEntry {
   agent?: AgentKind;
 }
 
-export interface SessionTarget {
-  key: string;
-  topic: TopicEntry;
-}
+export type SessionTarget = CatalogSessionTarget<AgentKind>;
 
 export interface McpTopicEntry {
   sessionId: string;
@@ -67,29 +68,7 @@ export type ValidateTargetResult =
 // --- Queries ---
 
 export function validateTarget(to: string): ValidateTargetResult {
-  const topics = getTopicsForUser();
-  const target = topics[to];
-  if (!target) {
-    const available = Object.entries(topics)
-      .filter(([name, topic]) => name !== currentTopic && Boolean(topic.agent))
-      .map(([name]) => name);
-    return {
-      ok: false,
-      error: {
-        content: [
-          {
-            type: "text" as const,
-            text: `Error: Session "${to}" not found.\nAvailable: ${available.join(", ") || "none"}`,
-          },
-        ],
-        isError: true,
-      },
-    };
-  }
-  // Topics without an active session (sessionId === "") are still valid
-  // targets — ask_session / tell_session deliveries will wake them with a
-  // fresh session via the session-inbox worker. See `session-inbox.ts`.
-  return { ok: true, target };
+  return sessionTargetCatalog.validateTarget(to);
 }
 
 function sessionTargetRows(): Array<{
@@ -130,42 +109,29 @@ function sessionTargetRows(): Array<{
 
 /** Canonical, deduplicated targets for display and status inspection. */
 export function listSessionTargetsForUser(): SessionTarget[] {
-  const eligibleRows = sessionTargetRows().filter((row) => row.kind !== "manager");
-  const titleCounts = new Map<string, number>();
-  for (const row of eligibleRows) {
-    const normalized = row.title.toLowerCase();
-    titleCounts.set(normalized, (titleCounts.get(normalized) ?? 0) + 1);
-  }
-  const rows = eligibleRows.filter((row) =>
-    currentTopicId ? row.id !== currentTopicId : row.title !== currentTopic,
-  );
-  return rows.map((row) => {
-    const agent = isAgentKind(row.agent) ? row.agent : undefined;
-    const kind = row.kind === "agent" ? "agent" : "channel";
-    const topic: TopicEntry = {
-      sessionId: row.session_id ?? "",
-      messageThreadId: 0,
-      name: row.title,
-      kind,
-      topicId: row.id,
-      ...(agent && { agent }),
-      ...(row.description && { description: row.description }),
-    };
-    const collision = (titleCounts.get(row.title.toLowerCase()) ?? 0) > 1;
-    return { key: collision ? `${kind}:${row.title}` : row.title, topic };
-  });
+  return sessionTargetCatalog.listTargets();
 }
 
 /** Lookup index with qualified aliases for every target and plain aliases when unambiguous. */
 export function getTopicsForUser(): { [name: string]: TopicEntry } {
-  const result: { [name: string]: TopicEntry } = {};
-  for (const { key, topic } of listSessionTargetsForUser()) {
-    result[`${topic.kind}:${topic.name}`] = topic;
-    result[key] = topic;
-  }
-  return result;
+  return sessionTargetCatalog.getTopics();
 }
 
+const sessionTargetCatalog = createSessionTargetCatalog<AgentKind>({
+  currentTopicId,
+  currentTopicName: currentTopic,
+  isAgent: isAgentKind,
+  listRows: () =>
+    sessionTargetRows().map((row) => ({
+      id: row.id,
+      title: row.title,
+      kind: row.kind,
+      agent: row.agent,
+      sessionId: row.session_id,
+      description: row.description,
+    })),
+});
+
 export function getMcpUserConfig(): McpUserConfig | null {
   if (!existsSync(SESSIONS_DB)) return null;
   try {

package/dist/runtime/src/platform/mcp-config.ts

@@ -1,4 +1,3 @@
-import { createHmac } from "node:crypto";
 import { canonicalMcpBridgeEnv } from "#mcp/canonical-bridge-config";
 import { buildRuntimeMcpSpec, RUNTIME_MCP_KEY } from "#mcp/runtime-spec";
 import { peerSessionBridgeIpcEnv } from "#mcp/session-comm/bridge-ipc-config";
@@ -24,6 +23,7 @@ import {
   commonRuntimeMcpPolicy,
   type RuntimeMcpScope,
 } from "#platform/mcp-catalog-policy";
+import { browserOwnerCapability } from "#platform/playwright/capability";
 import type { AgentKind, AgentQueryOptions, PeerRuntimeBridgeContext } from "#types";
 
 export type { RuntimeMcpScope } from "#platform/mcp-catalog-policy";
@@ -216,9 +216,7 @@ export interface RuntimeMcpCatalogEntry {
 
 export const CODEX_BROWSER_CAPABILITY_ENV = "NEGOTIUM_BROWSER_CAPABILITY";
 
-export function browserOwnerCapability(capability: string, owner: string): string {
-  return createHmac("sha256", capability).update(owner).digest("hex");
-}
+export { browserOwnerCapability };
 
 export function browserOwnerForContext(ctx: {
   userId?: string;

package/dist/runtime/src/platform/playwright/browser-processes.ts

@@ -145,7 +145,8 @@ export function cleanupZombiePlaywright(): void {
  */
 export function killBrowserProcsForUserDataDir(userDataDir: string): void {
   const target = resolve(userDataDir);
-  if (!target.startsWith(resolve(BROWSER_PROFILES_DIR))) return;
+  const profileRoot = resolve(BROWSER_PROFILES_DIR);
+  if (target !== profileRoot && !target.startsWith(`${profileRoot}${sep}`)) return;
   let pids: string;
   try {
     pids = execFileSync("pgrep", ["-f", "--", userDataDir], { stdio: "pipe" }).toString().trim();
@@ -194,7 +195,7 @@ export function selectOrphanBrowserPids(
   for (const { pid, userDataDir } of procs) {
     if (pid === selfPid || !userDataDir) continue;
     const dir = resolve(userDataDir);
-    if (!dir.startsWith(root)) continue; // never touch Chrome outside our dir
+    if (dir !== root && !dir.startsWith(`${root}${sep}`)) continue;
     if (live.has(dir)) continue; // belongs to a tracked instance
     out.push(pid);
   }

package/dist/runtime/src/platform/playwright/capability.ts

@@ -0,0 +1,5 @@
+import { createHmac } from "node:crypto";
+
+export function browserOwnerCapability(capability: string, owner: string): string {
+  return createHmac("sha256", capability).update(owner).digest("hex");
+}