negotium 0.1.6 → 0.1.8

package/dist/chunk-0ay6cjdy.js

@@ -0,0 +1,1331 @@
+import {
+  GENERAL_TOPIC_ID,
+  getManagerTopicForUser,
+  upsertTopic
+} from "./chunk-xfq68rch.js";
+import {
+  getApiTopicConfig,
+  setApiTopicConfig
+} from "./chunk-gmy11efb.js";
+import {
+  db
+} from "./chunk-7xqj7aex.js";
+import {
+  getRegistry
+} from "./chunk-5ahkew9c.js";
+import {
+  sanitizeTopicName
+} from "./chunk-6cpn7ht2.js";
+import {
+  BROWSER_PROFILES_DIR,
+  PATCHRIGHT_MCP_BIN,
+  PLAYWRIGHT_BASE_PORT,
+  PLAYWRIGHT_MAX_PORT,
+  PLAYWRIGHT_MCP_BIN,
+  PLAYWRIGHT_PORTS_DIR,
+  logger,
+  resolveBrowserProxy,
+  resolveDefaultModel
+} from "./chunk-k9z47mab.js";
+
+// ../../packages/core/src/storage/runtime-events.ts
+var RUNTIME_EVENT_TYPES = [
+  "message",
+  "message-updated",
+  "ai-status",
+  "topic-created",
+  "topic-updated",
+  "topic-deleted"
+];
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_events (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_id TEXT NOT NULL,
+    event_type TEXT NOT NULL CHECK (
+      event_type IN (
+        'message',
+        'message-updated',
+        'ai-status',
+        'topic-created',
+        'topic-updated',
+        'topic-deleted'
+      )
+    ),
+    topic_id TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )
+`);
+db.exec("CREATE INDEX IF NOT EXISTS idx_runtime_events_topic_seq ON runtime_events(topic_id, seq)");
+var types = new Set(RUNTIME_EVENT_TYPES);
+function rowToEvent(row) {
+  if (!types.has(row.event_type))
+    return null;
+  try {
+    return {
+      seq: Number(row.seq),
+      sourceId: row.source_id,
+      type: row.event_type,
+      topicId: row.topic_id,
+      payload: JSON.parse(row.payload_json),
+      createdAt: row.created_at
+    };
+  } catch {
+    return null;
+  }
+}
+function latestRuntimeEventSeq() {
+  const row = db.query("SELECT MAX(seq) AS seq FROM runtime_events").get();
+  return Number(row?.seq ?? 0);
+}
+function appendRuntimeEvent(sourceId, event) {
+  const createdAt = new Date().toISOString();
+  const result = db.query(`INSERT INTO runtime_events
+         (source_id, event_type, topic_id, payload_json, created_at)
+       VALUES (?, ?, ?, ?, ?)`).run(sourceId, event.type, event.topicId, JSON.stringify(event.payload ?? null), createdAt);
+  const seq = Number(result.lastInsertRowid);
+  return { seq, sourceId, ...event, createdAt };
+}
+function listRuntimeEventsAfter(seq, limit = 500) {
+  const rows = db.query(`SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+       FROM runtime_events
+       WHERE seq > ?
+       ORDER BY seq ASC
+       LIMIT ?`).all(Math.max(0, seq), Math.max(1, Math.min(limit, 5000)));
+  return rows.map(rowToEvent).filter((event) => event !== null);
+}
+function listRecentRuntimeEventsForTopic(topicId, limit = 300) {
+  const rows = db.query(`SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+       FROM (
+         SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+         FROM runtime_events
+         WHERE topic_id = ? AND event_type IN ('ai-status', 'message-updated')
+         ORDER BY seq DESC
+         LIMIT ?
+       )
+       ORDER BY seq ASC`).all(topicId, Math.max(1, Math.min(limit, 2000)));
+  return rows.map(rowToEvent).filter((event) => event !== null);
+}
+
+// ../../packages/core/src/bus.ts
+import { randomUUID } from "crypto";
+class SqliteRuntimeBus {
+  listeners = new Set;
+  sourceId;
+  pollIntervalMs;
+  cursor;
+  pollTimer = null;
+  polling = false;
+  constructor(options = {}) {
+    this.sourceId = options.sourceId ?? `${process.pid}-${randomUUID()}`;
+    this.pollIntervalMs = Math.max(25, options.pollIntervalMs ?? 100);
+    this.cursor = latestRuntimeEventSeq();
+  }
+  deliver(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  emit(event) {
+    const stored = appendRuntimeEvent(this.sourceId, event);
+    this.deliver({ ...event, seq: stored.seq, createdAt: stored.createdAt });
+  }
+  startPolling() {
+    if (this.pollTimer)
+      return;
+    this.pollTimer = setInterval(() => this.poll(), this.pollIntervalMs);
+    this.pollTimer.unref?.();
+    this.poll();
+  }
+  stopPolling() {
+    if (!this.pollTimer)
+      return;
+    clearInterval(this.pollTimer);
+    this.pollTimer = null;
+  }
+  poll() {
+    if (this.polling || this.listeners.size === 0)
+      return;
+    this.polling = true;
+    try {
+      while (true) {
+        const events = listRuntimeEventsAfter(this.cursor);
+        if (events.length === 0)
+          break;
+        for (const event of events) {
+          this.cursor = Math.max(this.cursor, event.seq);
+          if (event.sourceId === this.sourceId)
+            continue;
+          this.deliver({
+            type: event.type,
+            topicId: event.topicId,
+            payload: event.payload,
+            seq: event.seq,
+            createdAt: event.createdAt
+          });
+        }
+        if (events.length < 500)
+          break;
+      }
+    } finally {
+      this.polling = false;
+    }
+  }
+  broadcastMessage(topicId, message) {
+    this.emit({ type: "message", topicId, payload: message });
+  }
+  broadcastMessageUpdated(topicId, messageId, patch) {
+    this.emit({ type: "message-updated", topicId, payload: { messageId, patch } });
+  }
+  broadcastAiStatus(topicId, status) {
+    this.emit({ type: "ai-status", topicId, payload: status });
+  }
+  broadcastTopicCreated(topic) {
+    this.emit({ type: "topic-created", topicId: topic.id, payload: topic });
+  }
+  broadcastTopicUpdated(topicId) {
+    this.emit({ type: "topic-updated", topicId, payload: null });
+  }
+  broadcastTopicDeleted(topicId) {
+    this.emit({ type: "topic-deleted", topicId, payload: null });
+  }
+  broadcastAiActive(topicId, queryId) {
+    this.broadcastAiStatus(topicId, { kind: "ai_active", queryId });
+  }
+  broadcastDone(topicId, queryId, usage, meta) {
+    this.broadcastAiStatus(topicId, {
+      kind: "ai_done",
+      queryId,
+      usage,
+      agent: meta?.agent,
+      model: meta?.model
+    });
+  }
+  broadcastError(topicId, queryId, error) {
+    this.broadcastAiStatus(topicId, { kind: "ai_error", queryId, error });
+  }
+  broadcastAborted(topicId, queryId, reason) {
+    this.broadcastAiStatus(topicId, { kind: "ai_aborted", queryId, reason });
+  }
+  broadcastToolCall(topicId, queryId, name, input, label, toolUseId) {
+    const id = toolUseId.trim() || `${queryId}:tool`;
+    this.broadcastAiStatus(topicId, {
+      kind: "tool_call",
+      queryId,
+      name,
+      input,
+      label,
+      toolUseId: id
+    });
+  }
+  broadcastToolOutput(topicId, queryId, toolUseId, content) {
+    const id = toolUseId.trim() || `${queryId}:tool`;
+    this.broadcastAiStatus(topicId, { kind: "tool_output", queryId, toolUseId: id, content });
+  }
+  broadcastToolStatus(topicId, queryId, kind, content, meta) {
+    this.broadcastAiStatus(topicId, {
+      kind: "tool_status",
+      queryId,
+      statusKind: kind,
+      content,
+      toolName: meta?.toolName,
+      elapsed: meta?.elapsed
+    });
+  }
+  broadcastFileReady(topicId, queryId, path, source) {
+    this.broadcastAiStatus(topicId, { kind: "file_ready", queryId, path, source });
+  }
+  broadcastReasoning(topicId, queryId, content) {
+    this.broadcastAiStatus(topicId, { kind: "reasoning", queryId, content });
+  }
+  broadcastVisual(topicId, queryId, url, id, title, kind) {
+    this.broadcastAiStatus(topicId, { kind: "visual", queryId, url, id, title, visualKind: kind });
+  }
+  broadcastTyping(topicId, userId) {
+    this.broadcastAiStatus(topicId, { kind: "typing", userId });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.startPolling();
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0)
+        this.stopPolling();
+    };
+  }
+}
+var current = new SqliteRuntimeBus;
+function runtimeBus() {
+  return current;
+}
+function setRuntimeBus(bus) {
+  current = bus;
+}
+var WsHub = {
+  get() {
+    return current;
+  }
+};
+
+// ../../packages/core/src/storage/api-messages.ts
+db.exec(`
+  CREATE TABLE IF NOT EXISTS api_messages (
+    id TEXT PRIMARY KEY,
+    topic_id TEXT NOT NULL,
+    parent_id TEXT,
+    author_id TEXT NOT NULL,
+    source_adapter TEXT,
+    text TEXT NOT NULL,
+    query_id TEXT,
+    agent_type TEXT,
+    model TEXT,
+    attachments TEXT,
+    usage TEXT,
+    deleted INTEGER NOT NULL DEFAULT 0,
+    edited_at TEXT,
+    reactions TEXT,
+    kind TEXT,
+    ask_user_question TEXT,
+    mentions TEXT,
+    thread_root_id TEXT,
+    created_at TEXT NOT NULL
+  )
+`);
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN source_adapter TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN deleted INTEGER NOT NULL DEFAULT 0");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN edited_at TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN reactions TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN kind TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN ask_user_question TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN mentions TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN thread_root_id TEXT");
+} catch {}
+try {
+  db.exec("ALTER TABLE api_messages ADD COLUMN subagent_card TEXT");
+} catch {}
+db.exec("CREATE INDEX IF NOT EXISTS idx_api_messages_topic ON api_messages(topic_id)");
+db.exec("CREATE INDEX IF NOT EXISTS idx_api_messages_thread_root ON api_messages(thread_root_id)");
+var appendHooks = new Set;
+function emitApiMessageAppended(msg) {
+  for (const hook of appendHooks) {
+    queueMicrotask(() => {
+      try {
+        Promise.resolve(hook(msg)).catch(() => {
+          return;
+        });
+      } catch {}
+    });
+  }
+}
+function rowToDto(r) {
+  return {
+    id: r.id,
+    topicId: r.topic_id,
+    parentId: r.parent_id ?? undefined,
+    authorId: r.author_id,
+    sourceAdapter: r.source_adapter ?? undefined,
+    text: r.text,
+    queryId: r.query_id ?? undefined,
+    agentType: r.agent_type ?? undefined,
+    model: r.model ?? undefined,
+    attachments: r.attachments ? JSON.parse(r.attachments) : undefined,
+    usage: r.usage ? JSON.parse(r.usage) : undefined,
+    deleted: r.deleted !== 0,
+    editedAt: r.edited_at ?? undefined,
+    reactions: r.reactions ? JSON.parse(r.reactions) : undefined,
+    kind: r.kind ?? undefined,
+    askUserQuestion: r.ask_user_question ? JSON.parse(r.ask_user_question) : undefined,
+    subagentCard: r.subagent_card ? JSON.parse(r.subagent_card) : undefined,
+    mentions: r.mentions ? JSON.parse(r.mentions) : undefined,
+    threadRootId: r.thread_root_id ?? undefined,
+    createdAt: r.created_at
+  };
+}
+function attachmentListHasFileId(raw, fileId) {
+  if (!raw)
+    return false;
+  try {
+    const attachments = JSON.parse(raw);
+    return Array.isArray(attachments) && attachments.some((attachment) => typeof attachment === "object" && attachment !== null && ("id" in attachment) && attachment.id === fileId);
+  } catch {
+    return false;
+  }
+}
+function appendApiMessage(msg, options = {}) {
+  const notify = options.notify ?? true;
+  const updateTopicLastMessageAt = options.updateTopicLastMessageAt ?? true;
+  let inserted = false;
+  db.transaction(() => {
+    const result = db.query(`INSERT INTO api_messages
+         (id, topic_id, parent_id, author_id, source_adapter, text, query_id, agent_type, model, attachments, usage, deleted, edited_at, reactions, kind, ask_user_question, subagent_card, mentions, thread_root_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO NOTHING`).run(msg.id, msg.topicId, msg.parentId ?? null, msg.authorId, msg.sourceAdapter ?? null, msg.text, msg.queryId ?? null, msg.agentType ?? null, msg.model ?? null, msg.attachments ? JSON.stringify(msg.attachments) : null, msg.usage ? JSON.stringify(msg.usage) : null, msg.deleted ? 1 : 0, msg.editedAt ?? null, msg.reactions?.length ? JSON.stringify(msg.reactions) : null, msg.kind ?? null, msg.askUserQuestion ? JSON.stringify(msg.askUserQuestion) : null, msg.subagentCard ? JSON.stringify(msg.subagentCard) : null, msg.mentions?.length ? JSON.stringify(msg.mentions) : null, msg.threadRootId ?? null, msg.createdAt);
+    inserted = Number(result.changes ?? 0) > 0;
+    if (inserted && updateTopicLastMessageAt && !msg.deleted) {
+      db.query(`UPDATE api_topics
+         SET last_message_at = CASE
+           WHEN last_message_at IS NULL OR last_message_at < ? THEN ?
+           ELSE last_message_at
+         END
+         WHERE id = ?`).run(msg.createdAt, msg.createdAt, msg.topicId);
+    }
+  })();
+  if (inserted && notify && !msg.deleted)
+    emitApiMessageAppended(msg);
+}
+function getApiMessage(topicId, messageId) {
+  const row = db.query("SELECT * FROM api_messages WHERE topic_id = ? AND id = ?").get(topicId, messageId);
+  return row ? rowToDto(row) : null;
+}
+function topicHasAttachmentFileId(topicId, fileId) {
+  const rows = db.query("SELECT attachments FROM api_messages WHERE topic_id = ? AND deleted = 0 AND attachments IS NOT NULL").all(topicId);
+  return rows.some((row) => attachmentListHasFileId(row.attachments, fileId));
+}
+function updateApiMessageText(topicId, messageId, text, editedAt = new Date().toISOString()) {
+  const res = db.query(`UPDATE api_messages
+       SET text = ?, edited_at = ?
+       WHERE topic_id = ? AND id = ? AND deleted = 0`).run(text, editedAt, topicId, messageId);
+  if (Number(res.changes ?? 0) === 0)
+    return null;
+  return getApiMessage(topicId, messageId);
+}
+function updateApiMessageUsage(topicId, messageId, usage) {
+  const res = db.query(`UPDATE api_messages
+       SET usage = ?
+       WHERE topic_id = ? AND id = ? AND deleted = 0`).run(JSON.stringify(usage), topicId, messageId);
+  if (Number(res.changes ?? 0) === 0)
+    return null;
+  return getApiMessage(topicId, messageId);
+}
+function updateApiMessageAskUserQuestion(topicId, messageId, askUserQuestion, editedAt = new Date().toISOString()) {
+  const res = db.query(`UPDATE api_messages
+       SET ask_user_question = ?, edited_at = ?
+       WHERE topic_id = ? AND id = ? AND deleted = 0 AND kind = 'ask_user_question'`).run(JSON.stringify(askUserQuestion), editedAt, topicId, messageId);
+  if (Number(res.changes ?? 0) === 0)
+    return null;
+  return getApiMessage(topicId, messageId);
+}
+function updateApiMessageSubagentCard(topicId, messageId, subagentCard, editedAt = new Date().toISOString()) {
+  const res = db.query(`UPDATE api_messages
+       SET subagent_card = ?, edited_at = ?
+       WHERE topic_id = ? AND id = ? AND deleted = 0 AND kind = 'subagent'`).run(JSON.stringify(subagentCard), editedAt, topicId, messageId);
+  if (Number(res.changes ?? 0) === 0)
+    return null;
+  return getApiMessage(topicId, messageId);
+}
+function listApiMessagesByKind(kind) {
+  const rows = db.query("SELECT * FROM api_messages WHERE kind = ? AND deleted = 0").all(kind);
+  return rows.map(rowToDto);
+}
+function softDeleteApiMessage(topicId, messageId) {
+  const res = db.query(`UPDATE api_messages
+       SET deleted = 1, text = ''
+       WHERE topic_id = ? AND id = ? AND deleted = 0`).run(topicId, messageId);
+  if (Number(res.changes ?? 0) === 0)
+    return null;
+  return getApiMessage(topicId, messageId);
+}
+function listApiMessages(topicId, options) {
+  const limit = Math.max(1, Math.min(options?.limit ?? 50, 200));
+  let anchorRowid = null;
+  if (options?.cursor) {
+    const cur = db.query("SELECT rowid AS rowid FROM api_messages WHERE topic_id = ? AND id = ?").get(topicId, options.cursor);
+    if (cur)
+      anchorRowid = cur.rowid;
+  }
+  const rows = anchorRowid !== null ? db.query(`SELECT *, rowid AS rowid FROM api_messages
+             WHERE topic_id = ? AND deleted = 0 AND thread_root_id IS NULL AND rowid < ?
+             ORDER BY rowid DESC
+             LIMIT ?`).all(topicId, anchorRowid, limit + 1) : db.query(`SELECT *, rowid AS rowid FROM api_messages
+             WHERE topic_id = ? AND deleted = 0 AND thread_root_id IS NULL
+             ORDER BY rowid DESC
+             LIMIT ?`).all(topicId, limit + 1);
+  const hasMore = rows.length > limit;
+  const pageRows = (hasMore ? rows.slice(0, limit) : rows).reverse();
+  const page = pageRows.map(rowToDto);
+  const summaries = getThreadSummaries(page.map((m) => m.id));
+  if (summaries.size > 0) {
+    for (const m of page) {
+      const s = summaries.get(m.id);
+      if (s) {
+        m.threadReplyCount = s.replyCount;
+        m.threadLastReplyAt = s.lastReplyAt;
+      }
+    }
+  }
+  return {
+    page,
+    cursor: page.length > 0 ? page[0].id : undefined,
+    hasMore
+  };
+}
+function getThreadSummaries(rootIds) {
+  const out = new Map;
+  const ids = [...new Set(rootIds)].filter(Boolean);
+  if (ids.length === 0)
+    return out;
+  const rows = db.query(`SELECT thread_root_id AS rootId, COUNT(*) AS replyCount, MAX(created_at) AS lastReplyAt
+       FROM api_messages
+       WHERE thread_root_id IN (${ids.map(() => "?").join(",")}) AND deleted = 0
+       GROUP BY thread_root_id`).all(...ids);
+  for (const r of rows) {
+    out.set(r.rootId, { replyCount: Number(r.replyCount), lastReplyAt: r.lastReplyAt });
+  }
+  return out;
+}
+function deleteMessagesForTopic(topicId) {
+  const res = db.query("DELETE FROM api_messages WHERE topic_id = ?").run(topicId);
+  return Number(res.changes ?? 0);
+}
+function copyMessagesForTopic(sourceTopicId, targetTopicId) {
+  const rows = db.query("SELECT * FROM api_messages WHERE topic_id = ? AND deleted = 0 ORDER BY rowid ASC").all(sourceTopicId);
+  if (rows.length === 0)
+    return 0;
+  const idMap = new Map(rows.map((r) => [r.id, crypto.randomUUID()]));
+  let copied = 0;
+  for (const r of rows) {
+    const newId = idMap.get(r.id);
+    if (!newId)
+      continue;
+    appendApiMessage({
+      ...rowToDto(r),
+      id: newId,
+      topicId: targetTopicId,
+      parentId: r.parent_id ? idMap.get(r.parent_id) ?? r.parent_id : undefined,
+      threadRootId: r.thread_root_id ? idMap.get(r.thread_root_id) ?? r.thread_root_id : undefined
+    }, { notify: false, updateTopicLastMessageAt: false });
+    copied++;
+  }
+  return copied;
+}
+function getAllMessagesForTopic(topicId) {
+  return db.query("SELECT *, rowid AS rowid FROM api_messages WHERE topic_id = ? AND deleted = 0 ORDER BY rowid ASC").all(topicId);
+}
+function getMessagesForTopicAfterRowid(topicId, afterRowid) {
+  return db.query("SELECT *, rowid AS rowid FROM api_messages WHERE topic_id = ? AND rowid > ? AND deleted = 0 ORDER BY rowid ASC").all(topicId, afterRowid);
+}
+
+// ../../packages/core/src/platform/delay.ts
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ../../packages/core/src/storage/browser-profiles.ts
+var DEFAULT_BROWSER_PROFILE = "default";
+function normalizeBrowserProfileName(name) {
+  const value = name.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9_-]{0,47}$/.test(value)) {
+    throw new Error("Profile name must be 1-48 lowercase letters, numbers, '-' or '_'.");
+  }
+  return value;
+}
+db.exec(`
+  CREATE TABLE IF NOT EXISTS browser_profiles (
+    owner_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (owner_id, name)
+  )
+`);
+function getBrowserProfileOwner(topicId, fallbackUserId) {
+  return db.query("SELECT browser_profile_owner FROM api_topics WHERE id = ?").get(topicId)?.browser_profile_owner ?? fallbackUserId;
+}
+function isTopicBrowserProfileOwner(topicId, userId) {
+  return getBrowserProfileOwner(topicId, "") === userId;
+}
+function getTopicBrowserProfile(topicId) {
+  const value = db.query("SELECT browser_profile FROM api_topics WHERE id = ?").get(topicId)?.browser_profile;
+  return value || DEFAULT_BROWSER_PROFILE;
+}
+function hasBrowserProfileTopic(topicId) {
+  return Boolean(db.query("SELECT id FROM api_topics WHERE id = ?").get(topicId));
+}
+function createBrowserProfile(ownerId, rawName) {
+  const name = normalizeBrowserProfileName(rawName);
+  if (name === DEFAULT_BROWSER_PROFILE)
+    return name;
+  db.query("INSERT OR IGNORE INTO browser_profiles (owner_id, name, created_at) VALUES (?, ?, ?)").run(ownerId, name, new Date().toISOString());
+  return name;
+}
+function assignTopicBrowserProfile(opts) {
+  const actualOwner = getBrowserProfileOwner(opts.topicId, "");
+  if (!actualOwner)
+    throw new Error(`Topic "${opts.topicId}" not found or has no owner.`);
+  if (actualOwner !== opts.actorUserId) {
+    throw new Error(`Only the topic owner can change its browser profile.`);
+  }
+  const profile = normalizeBrowserProfileName(opts.profile);
+  if (profile !== DEFAULT_BROWSER_PROFILE)
+    createBrowserProfile(actualOwner, profile);
+  const previous = getTopicBrowserProfile(opts.topicId);
+  const result = db.query("UPDATE api_topics SET browser_profile = ? WHERE id = ?").run(profile, opts.topicId);
+  if (Number(result.changes ?? 0) !== 1)
+    throw new Error(`Topic "${opts.topicId}" not found.`);
+  return { previous, profile };
+}
+
+// ../../packages/core/src/platform/playwright/manager.ts
+import { execFileSync, spawn } from "child_process";
+import { createHash, randomBytes } from "crypto";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, resolve } from "path";
+function makeInstanceKey(userId, topic) {
+  if (!topic)
+    return makeBrowserProfileInstanceKey(userId, "default");
+  const ownerId = getBrowserProfileOwner(topic, userId);
+  const profile = migrateLegacyTopicProfile(ownerId, topic);
+  return makeBrowserProfileInstanceKey(ownerId, profile);
+}
+function makeBrowserProfileInstanceKey(ownerId, rawProfile) {
+  return `profile:${encodeURIComponent(ownerId)}:${normalizeBrowserProfileName(rawProfile)}`;
+}
+function legacyBrowserProfileName(topic) {
+  return `legacy_${createHash("sha256").update(topic).digest("hex").slice(0, 12)}`;
+}
+function migrateLegacyTopicProfile(ownerId, topic) {
+  const current2 = getTopicBrowserProfile(topic);
+  if (current2 !== "default" || !hasBrowserProfileTopic(topic))
+    return current2;
+  const legacyDir = resolve(BROWSER_PROFILES_DIR, sanitizeTopicName(topic));
+  if (!existsSync(legacyDir))
+    return current2;
+  const profile = legacyBrowserProfileName(topic);
+  const profileDir = resolveProfileDir(ownerId, profile);
+  mkdirSync(dirname(profileDir), { recursive: true });
+  if (!existsSync(profileDir))
+    renameSync(legacyDir, profileDir);
+  assignTopicBrowserProfile({ topicId: topic, actorUserId: ownerId, profile });
+  logger.info({ ownerId, topic, profile }, "Adopted legacy topic browser profile");
+  return profile;
+}
+function parseInstanceKey(instanceKey) {
+  const match = /^profile:([^:]+):(.+)$/.exec(instanceKey);
+  if (!match)
+    return { ownerId: "legacy", profile: sanitizeTopicName(instanceKey) };
+  return {
+    ownerId: decodeURIComponent(match[1]),
+    profile: normalizeBrowserProfileName(match[2])
+  };
+}
+function portFileName(instanceKey) {
+  return createHash("sha256").update(instanceKey).digest("hex").slice(0, 24);
+}
+function writePortFile(instanceKey, port) {
+  try {
+    mkdirSync(PLAYWRIGHT_PORTS_DIR, { recursive: true });
+    writeFileSync(join(PLAYWRIGHT_PORTS_DIR, portFileName(instanceKey)), String(port));
+  } catch (e) {
+    logger.warn({ err: e, instanceKey, port }, "Failed to save playwright port file");
+  }
+}
+function deletePortFile(instanceKey) {
+  try {
+    unlinkSync(join(PLAYWRIGHT_PORTS_DIR, portFileName(instanceKey)));
+  } catch (e) {
+    logger.warn({ err: e, instanceKey }, "Failed to delete playwright port file");
+  }
+}
+var BASE_PORT = PLAYWRIGHT_BASE_PORT;
+var MAX_PORT = PLAYWRIGHT_MAX_PORT;
+var MAX_IDLE_MS = 2 * 60 * 60 * 1000;
+var instances = new Map;
+var usedPorts = new Set;
+var spawning = new Map;
+async function withPlaywrightInstanceMaintenance(rawKeys, operation) {
+  const keys = [...new Set(rawKeys)].sort();
+  for (;; ) {
+    const pending = keys.map((key) => spawning.get(key)).filter((promise) => promise !== undefined);
+    if (pending.length > 0) {
+      await Promise.allSettled(pending);
+      continue;
+    }
+    let releaseBarrier;
+    const barrier = new Promise((resolveBarrier) => {
+      releaseBarrier = () => resolveBarrier(null);
+    });
+    for (const key of keys)
+      spawning.set(key, barrier);
+    try {
+      return await operation();
+    } finally {
+      for (const key of keys) {
+        if (spawning.get(key) === barrier)
+          spawning.delete(key);
+      }
+      releaseBarrier();
+    }
+  }
+}
+var pinnedInstances = new Map;
+function pinPlaywrightInstance(instanceKey) {
+  pinnedInstances.set(instanceKey, (pinnedInstances.get(instanceKey) ?? 0) + 1);
+}
+function unpinPlaywrightInstance(instanceKey) {
+  const count = pinnedInstances.get(instanceKey);
+  if (count === undefined)
+    return;
+  if (count <= 1)
+    pinnedInstances.delete(instanceKey);
+  else
+    pinnedInstances.set(instanceKey, count - 1);
+}
+function getPlaywrightCapability(instanceKey) {
+  return instances.get(instanceKey)?.capability;
+}
+var _onPlaywrightExit = null;
+function evictIdleInstance() {
+  const now = Date.now();
+  const oldestKey = selectIdleEvictionKey(instances, pinnedInstances.keys(), spawning.keys(), now, MAX_IDLE_MS);
+  if (oldestKey) {
+    const instance = instances.get(oldestKey);
+    if (!instance)
+      return null;
+    const idleMin = ((now - instance.lastUsedAt) / 60000).toFixed(0);
+    logger.info({ key: oldestKey, idleMin }, "Evicting idle playwright instance");
+    killInstance(oldestKey);
+    return instance.port;
+  }
+  return null;
+}
+function selectIdleEvictionKey(candidates, pinnedKeys, busyKeys, now, maxIdleMs) {
+  const pinned = new Set(pinnedKeys);
+  const busy = new Set(busyKeys);
+  let oldest = null;
+  for (const [key, instance] of candidates) {
+    if (pinned.has(key) || busy.has(key))
+      continue;
+    if (now - instance.lastUsedAt < maxIdleMs)
+      continue;
+    if (!oldest || instance.lastUsedAt < oldest.lastUsedAt) {
+      oldest = { key, lastUsedAt: instance.lastUsedAt };
+    }
+  }
+  return oldest?.key ?? null;
+}
+async function allocatePort(expectedUserDataDir) {
+  for (let port = BASE_PORT;port <= MAX_PORT; port++) {
+    if (usedPorts.has(port))
+      continue;
+    usedPorts.add(port);
+    if (isPortInUse(port)) {
+      logger.warn({ port }, "Port occupied by external process, attempting cleanup");
+      await killPlaywrightOnPort(port, expectedUserDataDir);
+      if (isPortInUse(port)) {
+        usedPorts.delete(port);
+        continue;
+      }
+    }
+    return port;
+  }
+  const evictedPort = evictIdleInstance();
+  if (evictedPort !== null) {
+    await waitForPortRelease(evictedPort);
+    const reusablePort = selectReusablePort(BASE_PORT, MAX_PORT, usedPorts, isPortInUse);
+    if (reusablePort !== null) {
+      usedPorts.add(reusablePort);
+      return reusablePort;
+    }
+  }
+  throw new Error(`No available ports for Playwright MCP (${instances.size} active instances, range ${BASE_PORT}-${MAX_PORT})`);
+}
+function selectReusablePort(minPort, maxPort, reservedPorts, isOccupied) {
+  for (let port = minPort;port <= maxPort; port++) {
+    if (reservedPorts.has(port) || isOccupied(port))
+      continue;
+    return port;
+  }
+  return null;
+}
+function releasePort(port) {
+  usedPorts.delete(port);
+}
+function isPortInUse(port) {
+  try {
+    execFileSync("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractUserDataDirArg(cmdline) {
+  const m = cmdline.match(/--user-data-dir(?:\s+|=)(\S+)/);
+  return m ? m[1] : null;
+}
+async function killPlaywrightOnPort(port, expectedUserDataDir) {
+  try {
+    const pids = execFileSync("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim();
+    if (!pids)
+      return;
+    for (const pid of pids.split(`
+`)) {
+      try {
+        const cmdline = execFileSync("ps", ["-p", pid, "-o", "command="], { stdio: "pipe" }).toString().trim();
+        if (!cmdline.includes("mcp-patchright")) {
+          logger.warn({ port, pid, cmdline: cmdline.slice(0, 80) }, "Port occupied by non-browser-MCP process, skipping");
+          continue;
+        }
+        if (expectedUserDataDir) {
+          const otherDataDir = extractUserDataDirArg(cmdline);
+          if (!browserProcessMatchesExpectedProfile(cmdline, expectedUserDataDir)) {
+            logger.warn({
+              port,
+              pid,
+              otherDataDir,
+              expectedUserDataDir
+            }, "Port occupied by another topic's playwright-mcp, skipping");
+            continue;
+          }
+        }
+        const pidNum = parseInt(pid, 10);
+        if (!Number.isNaN(pidNum)) {
+          killProcessTreeChildren(pidNum);
+          process.kill(pidNum, "SIGKILL");
+        }
+        logger.info({ pid, port }, "Killed zombie mcp-patchright");
+      } catch (e) {
+        logger.warn({ err: e, port }, "Failed to inspect process occupying port");
+      }
+    }
+  } catch (e) {
+    logger.warn({ err: e, port }, "Failed to check processes on port");
+  }
+  const start = Date.now();
+  while (Date.now() - start < 3000) {
+    if (!isPortInUse(port))
+      return;
+    await delay(200);
+  }
+}
+function browserProcessMatchesExpectedProfile(cmdline, expectedUserDataDir) {
+  const actualUserDataDir = extractUserDataDirArg(cmdline);
+  return actualUserDataDir !== null && resolve(actualUserDataDir) === resolve(expectedUserDataDir);
+}
+function killBrowserProcsForUserDataDir(userDataDir) {
+  const target = resolve(userDataDir);
+  if (!target.startsWith(resolve(BROWSER_PROFILES_DIR)))
+    return;
+  let pids;
+  try {
+    pids = execFileSync("pgrep", ["-f", "--", userDataDir], { stdio: "pipe" }).toString().trim();
+  } catch {
+    return;
+  }
+  if (!pids)
+    return;
+  for (const pid of pids.split(`
+`)) {
+    const pidNum = parseInt(pid.trim(), 10);
+    if (Number.isNaN(pidNum) || pidNum === process.pid)
+      continue;
+    try {
+      const cmdline = execFileSync("ps", ["-p", String(pidNum), "-o", "command="], {
+        stdio: "pipe"
+      }).toString().trim();
+      const argDir = extractUserDataDirArg(cmdline);
+      if (!argDir || resolve(argDir) !== target)
+        continue;
+      killProcessTreeChildren(pidNum);
+      process.kill(pidNum, "SIGKILL");
+      logger.info({ pid: pidNum, userDataDir }, "Reaped orphaned browser process by user-data-dir");
+    } catch (e) {
+      logger.debug({ err: e, pid: pidNum, userDataDir }, "Failed to reap browser proc by dir");
+    }
+  }
+}
+function selectOrphanBrowserPids(procs, liveUserDataDirs, profileRoot, selfPid) {
+  const root = resolve(profileRoot);
+  const live = new Set([...liveUserDataDirs].map((d) => resolve(d)));
+  const out = [];
+  for (const { pid, userDataDir } of procs) {
+    if (pid === selfPid || !userDataDir)
+      continue;
+    const dir = resolve(userDataDir);
+    if (!dir.startsWith(root))
+      continue;
+    if (live.has(dir))
+      continue;
+    out.push(pid);
+  }
+  return out;
+}
+function reapOrphanBrowsers() {
+  const profileRoot = resolve(BROWSER_PROFILES_DIR);
+  let pids;
+  try {
+    pids = execFileSync("pgrep", ["-f", "--", profileRoot], { stdio: "pipe" }).toString().trim();
+  } catch {
+    return;
+  }
+  if (!pids)
+    return;
+  const procs = [];
+  for (const pid of pids.split(`
+`)) {
+    const pidNum = parseInt(pid.trim(), 10);
+    if (Number.isNaN(pidNum))
+      continue;
+    try {
+      const cmdline = execFileSync("ps", ["-p", String(pidNum), "-o", "command="], {
+        stdio: "pipe"
+      }).toString().trim();
+      procs.push({ pid: pidNum, userDataDir: extractUserDataDirArg(cmdline) });
+    } catch {}
+  }
+  const liveDirs = [...instances.keys()].map(resolveUserDataDir);
+  const orphanPids = selectOrphanBrowserPids(procs, liveDirs, profileRoot, process.pid);
+  for (const pid of orphanPids) {
+    try {
+      killProcessTreeChildren(pid);
+      process.kill(pid, "SIGKILL");
+      logger.info({ pid }, "Reaped orphaned browser process (janitor)");
+    } catch (e) {
+      logger.debug({ err: e, pid }, "Janitor failed to reap orphaned browser process");
+    }
+  }
+}
+async function isHealthy(port) {
+  for (const path of ["/health", "/sse?owner=__negotium_health__"]) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+        signal: AbortSignal.timeout(2000)
+      });
+      await res.body?.cancel();
+      if (res.ok)
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function cleanSingletonFiles(userDataDir) {
+  try {
+    const files = readdirSync(userDataDir);
+    for (const f of files) {
+      if (f.startsWith("Singleton")) {
+        try {
+          unlinkSync(resolve(userDataDir, f));
+          logger.info({ file: f, userDataDir }, "Removed stale Singleton file");
+        } catch (e) {
+          logger.warn({ err: e, file: f }, "Failed to remove stale Chrome Singleton file");
+        }
+      }
+    }
+  } catch {}
+}
+function killProcessTreeChildren(pid) {
+  try {
+    const children = execFileSync("pgrep", ["-P", String(pid)], { stdio: "pipe" }).toString().trim();
+    if (!children)
+      return;
+    const childPids = children.split(`
+`).map((cpid) => parseInt(cpid, 10)).filter((pidNum) => !Number.isNaN(pidNum));
+    for (const childPid of childPids) {
+      killProcessTreeChildren(childPid);
+    }
+    for (const signal of ["SIGTERM", "SIGKILL"]) {
+      for (const childPid of childPids) {
+        try {
+          process.kill(childPid, signal);
+        } catch (e) {
+          logger.debug({ err: e, pid: childPid, signal }, "Failed to signal browser child process");
+        }
+      }
+    }
+    logger.info({ parentPid: pid, childPids }, "Killed browser-MCP child process tree");
+  } catch {}
+}
+function ownerDirectory(ownerId) {
+  const digest = createHash("sha256").update(ownerId).digest("hex").slice(0, 16);
+  return `${sanitizeTopicName(ownerId).slice(0, 24)}_${digest}`;
+}
+function resolveProfileDir(ownerId, profile) {
+  return resolve(BROWSER_PROFILES_DIR, "profiles", ownerDirectory(ownerId), profile);
+}
+function resolveUserDataDir(instanceKey) {
+  const { ownerId, profile } = parseInstanceKey(instanceKey);
+  return resolveProfileDir(ownerId, profile);
+}
+function killInstance(instanceKey, opts) {
+  const inst = instances.get(instanceKey);
+  if (!inst)
+    return;
+  if (inst.process.pid) {
+    killProcessTreeChildren(inst.process.pid);
+  }
+  try {
+    inst.process.kill("SIGTERM");
+  } catch (e) {
+    logger.warn({ err: e, instanceKey }, "Failed to kill playwright instance");
+  }
+  inst.process.removeAllListeners("error");
+  inst.process.removeAllListeners("exit");
+  cleanSingletonFiles(resolveUserDataDir(instanceKey));
+  if (!opts?.keepPort)
+    releasePort(inst.port);
+  instances.delete(instanceKey);
+  deletePortFile(instanceKey);
+  logger.info({ instanceKey, port: inst.port, keepPort: !!opts?.keepPort }, "Killed Playwright MCP (with cleanup)");
+}
+async function spawnPlaywright(instanceKey, userId, reservedPort, browserBin = PLAYWRIGHT_MCP_BIN, allowFallback = true) {
+  const userDataDir = resolveUserDataDir(instanceKey);
+  const port = reservedPort ?? await allocatePort(userDataDir);
+  mkdirSync(userDataDir, { recursive: true });
+  const mcpArgs = [
+    "--port",
+    String(port),
+    "--host",
+    "127.0.0.1",
+    "--user-data-dir",
+    userDataDir
+  ];
+  const proxy = resolveBrowserProxy();
+  const capability = randomBytes(32).toString("hex");
+  const childEnv = {
+    ...process.env,
+    NEGOTIUM_BROWSER_CAPABILITY: capability,
+    ...proxy ? {
+      NEGOTIUM_BROWSER_PROXY_SERVER: proxy.server,
+      ...proxy.username ? { NEGOTIUM_BROWSER_PROXY_USERNAME: proxy.username } : {},
+      ...proxy.password ? { NEGOTIUM_BROWSER_PROXY_PASSWORD: proxy.password } : {},
+      ...proxy.bypass ? { NEGOTIUM_BROWSER_PROXY_BYPASS: proxy.bypass } : {}
+    } : {}
+  };
+  if (proxy) {
+    logger.info({ instanceKey, proxyServer: proxy.server }, "Browser egress proxy enabled");
+  }
+  const command = browserBin.endsWith(".mjs") ? process.execPath : browserBin;
+  const args = browserBin.endsWith(".mjs") ? [browserBin, ...mcpArgs] : mcpArgs;
+  const proc = spawn(command, args, {
+    stdio: "ignore",
+    detached: false,
+    env: childEnv
+  });
+  const reapCrashedBrowser = () => {
+    const userDataDir2 = resolveUserDataDir(instanceKey);
+    killBrowserProcsForUserDataDir(userDataDir2);
+    cleanSingletonFiles(userDataDir2);
+  };
+  proc.once("error", (err) => {
+    logger.error({ err, instanceKey }, "Playwright MCP error");
+    if (instances.get(instanceKey)?.process === proc) {
+      releasePort(port);
+      instances.delete(instanceKey);
+      reapCrashedBrowser();
+    }
+  });
+  proc.once("exit", (code) => {
+    logger.info({ instanceKey, code }, "Playwright MCP exited");
+    const wasOurs = instances.get(instanceKey)?.process === proc;
+    if (wasOurs) {
+      releasePort(port);
+      instances.delete(instanceKey);
+      reapCrashedBrowser();
+      _onPlaywrightExit?.(instanceKey, code);
+    }
+  });
+  const now = Date.now();
+  instances.set(instanceKey, {
+    process: proc,
+    port,
+    userId,
+    startedAt: now,
+    lastUsedAt: now,
+    capability
+  });
+  const ready = await waitForServer(port, 1e4) && await supportsOwnerCleanup(port, capability);
+  if (!ready) {
+    const exitCode = proc.exitCode;
+    killInstance(instanceKey);
+    if (allowFallback && browserBin !== PATCHRIGHT_MCP_BIN) {
+      logger.warn({ instanceKey, browserBin, fallback: PATCHRIGHT_MCP_BIN }, "Preferred browser MCP unavailable or lacks owner isolation; using Patchright fallback");
+      return spawnPlaywright(instanceKey, userId, undefined, PATCHRIGHT_MCP_BIN, false);
+    }
+    throw new Error(`Playwright MCP failed health check after spawn on port ${port}` + (exitCode === null ? "" : ` (exitCode=${exitCode})`));
+  }
+  writePortFile(instanceKey, port);
+  logger.info({ instanceKey, port, pid: proc.pid, ready }, "Playwright MCP started");
+  return port;
+}
+async function supportsOwnerCleanup(port, capability) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/owners`, {
+      method: "DELETE",
+      headers: {
+        "X-Browser-Owner": "__negotium_capability_probe__",
+        "X-Browser-Capability": capability
+      },
+      signal: AbortSignal.timeout(2000)
+    });
+    await response.body?.cancel();
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensurePlaywright(userId, topic) {
+  const instanceKey = makeInstanceKey(userId, topic);
+  const inProgress = spawning.get(instanceKey);
+  if (inProgress) {
+    const port = await inProgress;
+    if (port !== null)
+      return port;
+    return ensurePlaywright(userId, topic);
+  }
+  const promise = (async () => {
+    const existing = instances.get(instanceKey);
+    if (existing && !existing.process.killed && existing.process.exitCode === null) {
+      if (await isHealthy(existing.port)) {
+        existing.lastUsedAt = Date.now();
+        return existing.port;
+      }
+      logger.warn({ instanceKey }, "Playwright MCP unresponsive, restarting");
+      const oldPort = existing.port;
+      killInstance(instanceKey);
+      await waitForPortRelease(oldPort);
+      cleanSingletonFiles(resolveUserDataDir(instanceKey));
+    } else if (existing) {
+      releasePort(existing.port);
+      instances.delete(instanceKey);
+      cleanSingletonFiles(resolveUserDataDir(instanceKey));
+    }
+    return spawnPlaywright(instanceKey, userId);
+  })().finally(() => spawning.delete(instanceKey));
+  spawning.set(instanceKey, promise);
+  return promise;
+}
+async function waitForPortRelease(port, timeoutMs = 3000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isPortInUse(port))
+      return;
+    await delay(200);
+  }
+}
+async function closeBrowserOwnerTabs(ownerId, rawProfile, owner) {
+  const instanceKey = makeBrowserProfileInstanceKey(ownerId, rawProfile);
+  const inProgress = spawning.get(instanceKey);
+  if (inProgress)
+    await inProgress;
+  const instance = instances.get(instanceKey);
+  if (!instance)
+    return 0;
+  const port = instance.port;
+  const response = await fetch(`http://127.0.0.1:${port}/owners`, {
+    method: "DELETE",
+    headers: {
+      "X-Browser-Owner": owner,
+      "X-Browser-Capability": instance.capability
+    },
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!response.ok)
+    throw new Error(`browser MCP owner cleanup failed (${response.status})`);
+  const result = await response.json();
+  return typeof result.closed === "number" ? result.closed : 0;
+}
+async function waitForServer(port, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await isHealthy(port))
+      return true;
+    await delay(300);
+  }
+  logger.warn({ port, timeoutMs }, "Playwright MCP not ready before timeout");
+  return false;
+}
+async function cloneProfileForChild(opts) {
+  const srcOwner = getBrowserProfileOwner(opts.srcTopic, opts.userId);
+  const dstOwner = getBrowserProfileOwner(opts.dstTopic, opts.userId);
+  if (srcOwner !== dstOwner) {
+    const dstDir2 = resolveProfileDir(dstOwner, getTopicBrowserProfile(opts.dstTopic));
+    return {
+      copied: false,
+      srcDir: resolveProfileDir(srcOwner, getTopicBrowserProfile(opts.srcTopic)),
+      dstDir: dstDir2,
+      reason: "cross-owner-fresh-profile"
+    };
+  }
+  if (srcOwner === dstOwner && hasBrowserProfileTopic(opts.dstTopic)) {
+    const profile = getTopicBrowserProfile(opts.srcTopic);
+    assignTopicBrowserProfile({ topicId: opts.dstTopic, actorUserId: dstOwner, profile });
+    const sharedDir = resolveProfileDir(srcOwner, profile);
+    return {
+      copied: false,
+      srcDir: sharedDir,
+      dstDir: sharedDir,
+      reason: "shared-profile-assignment"
+    };
+  }
+  const srcKey = makeInstanceKey(opts.userId, opts.srcTopic);
+  const dstKey = makeInstanceKey(opts.userId, opts.dstTopic);
+  const srcDir = resolveUserDataDir(srcKey);
+  const dstDir = resolveUserDataDir(dstKey);
+  if (srcDir === dstDir) {
+    return { copied: false, srcDir, dstDir, reason: "same-dir" };
+  }
+  return withPlaywrightInstanceMaintenance([srcKey, dstKey], async () => {
+    const parentWasLive = instances.has(srcKey);
+    if (parentWasLive) {
+      logger.info({ srcKey }, "Quiescing parent Playwright before profile clone");
+      killInstance(srcKey);
+      await delay(1500);
+    }
+    if (instances.has(dstKey)) {
+      killInstance(dstKey);
+      await delay(500);
+    }
+    if (!existsSync(srcDir)) {
+      return { copied: false, srcDir, dstDir, reason: "src-missing" };
+    }
+    try {
+      if (existsSync(dstDir)) {
+        rmSync(dstDir, { recursive: true, force: true });
+      }
+      mkdirSync(dirname(dstDir), { recursive: true });
+      if (process.platform === "darwin") {
+        try {
+          execFileSync("cp", ["-cR", srcDir, dstDir], { stdio: "pipe" });
+        } catch {
+          cpSync(srcDir, dstDir, { recursive: true });
+        }
+      } else {
+        cpSync(srcDir, dstDir, { recursive: true });
+      }
+    } catch (e) {
+      const reason = `copy-failed: ${e instanceof Error ? e.message : String(e)}`;
+      logger.warn({ srcDir, dstDir, err: e }, "Playwright profile clone failed");
+      return { copied: false, srcDir, dstDir, reason };
+    }
+    cleanSingletonFiles(dstDir);
+    for (const f of ["DevToolsActivePort", "LOCK"]) {
+      try {
+        unlinkSync(resolve(dstDir, f));
+      } catch {}
+    }
+    logger.info({ srcKey, dstKey, srcDir, dstDir }, "Cloned Playwright profile for child topic");
+    return { copied: true, srcDir, dstDir };
+  });
+}
+function deleteTopicProfileDir(userId, topic) {
+  const key = makeInstanceKey(userId, topic);
+  const dir = resolveUserDataDir(key);
+  logger.info({ dir, userId, topic }, "Preserved shared browser profile on topic deletion");
+  return { deleted: false, dir };
+}
+async function killAllPlaywright() {
+  const procs = [...instances.entries()].map(([key, inst]) => ({ key, proc: inst.process }));
+  for (const { key } of procs)
+    killInstance(key);
+  await Promise.all(procs.map(async ({ key, proc }) => {
+    if (await waitForChildProcessExit(proc, 3000))
+      return;
+    logger.warn({ instanceKey: key, pid: proc.pid }, "Playwright MCP ignored SIGTERM");
+    try {
+      proc.kill("SIGKILL");
+    } catch (err) {
+      logger.warn({ err, instanceKey: key, pid: proc.pid }, "Failed to SIGKILL Playwright MCP");
+    }
+    if (!await waitForChildProcessExit(proc, 1000)) {
+      logger.warn({ instanceKey: key, pid: proc.pid }, "Playwright MCP did not report exit");
+    }
+  }));
+}
+function waitForChildProcessExit(proc, timeoutMs) {
+  if (proc.exitCode !== null || proc.signalCode !== null)
+    return Promise.resolve(true);
+  return new Promise((resolveWait) => {
+    let settled = false;
+    let timer;
+    const finish = (exited) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      proc.off("exit", onExit);
+      resolveWait(exited);
+    };
+    const onExit = () => finish(true);
+    proc.once("exit", onExit);
+    timer = setTimeout(() => finish(proc.exitCode !== null || proc.signalCode !== null), timeoutMs);
+    if (typeof timer === "object")
+      timer.unref?.();
+    if (proc.exitCode !== null || proc.signalCode !== null)
+      finish(true);
+  });
+}
+setInterval(() => {
+  while (evictIdleInstance() !== null) {}
+  try {
+    reapOrphanBrowsers();
+  } catch (e) {
+    logger.debug({ err: e }, "reapOrphanBrowsers sweep failed");
+  }
+}, 30 * 60 * 1000).unref();
+
+// ../../packages/core/src/topics/personal-general.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var LEGACY_PERSONAL_GENERAL_DESCRIPTION = "\uB098\uB9CC\uC758 \uAC1C\uC778 \uACF5\uAC04\uC774\uC5D0\uC694. \uB300\uD654\uC640 AI \uC791\uC5C5\uC740 \uB2E4\uB978 \uC0AC\uC6A9\uC790\uC5D0\uAC8C \uACF5\uAC1C\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.";
+var PERSONAL_GENERAL_DESCRIPTION = "Your private General. Messages and membership are visible only to you. Workspace memory, wiki, and skills are shared with your workspace.";
+function ensurePersonalGeneral(userId) {
+  const existing = getManagerTopicForUser(userId);
+  if (existing) {
+    if (existing.description === LEGACY_PERSONAL_GENERAL_DESCRIPTION) {
+      existing.description = PERSONAL_GENERAL_DESCRIPTION;
+      upsertTopic(existing);
+    }
+    if (!getApiTopicConfig(existing.id)) {
+      setApiTopicConfig(existing.id, { model: "deepseek-pro", modelLocked: true });
+    }
+    return existing;
+  }
+  const now = new Date().toISOString();
+  const registry = getRegistry("maestro");
+  const topic = {
+    id: randomUUID2(),
+    title: "General",
+    description: PERSONAL_GENERAL_DESCRIPTION,
+    kind: "manager",
+    agent: "maestro",
+    defaultModel: resolveDefaultModel("maestro", registry.defaultModel),
+    defaultEffort: registry.defaultEffort ?? "medium",
+    aiMode: "always",
+    aiMention: false,
+    participants: [{ userId, role: "owner" }],
+    createdAt: now,
+    lastMessageAt: now
+  };
+  upsertTopic(topic);
+  setApiTopicConfig(topic.id, { model: "deepseek-pro", modelLocked: true });
+  return topic;
+}
+function isLegacySharedGeneral(topicId) {
+  return topicId === GENERAL_TOPIC_ID;
+}
+
+export { latestRuntimeEventSeq, listRuntimeEventsAfter, listRecentRuntimeEventsForTopic, runtimeBus, setRuntimeBus, WsHub, appendApiMessage, getApiMessage, topicHasAttachmentFileId, updateApiMessageText, updateApiMessageUsage, updateApiMessageAskUserQuestion, updateApiMessageSubagentCard, listApiMessagesByKind, softDeleteApiMessage, listApiMessages, deleteMessagesForTopic, copyMessagesForTopic, getAllMessagesForTopic, getMessagesForTopicAfterRowid, delay, getBrowserProfileOwner, isTopicBrowserProfileOwner, getTopicBrowserProfile, makeInstanceKey, pinPlaywrightInstance, unpinPlaywrightInstance, getPlaywrightCapability, ensurePlaywright, closeBrowserOwnerTabs, cloneProfileForChild, deleteTopicProfileDir, killAllPlaywright, ensurePersonalGeneral, isLegacySharedGeneral };
+
+//# debugId=FD285E5E50ECD13364756E2164756E21