@sideboard-ai/core 0.1.311 → 0.1.313

package/dist/{chunk-GQJOLTZU.js → chunk-2JOBQUUS.js}

@@ -5,10 +5,10 @@ import {
   brightsyMcpServerName,
   ensureCliTeamTracked,
   ensureConnectedBrightsyTeamTokens
-} from "./chunk-42JGPPVS.js";
+} from "./chunk-V5BTGQ6M.js";
 import {
   loadBrightsyConfig
-} from "./chunk-PXMLMBMI.js";
+} from "./chunk-E63AM3PW.js";
 import {
   httpFetch
 } from "./chunk-2GPQZZLY.js";
@@ -447,6 +447,9 @@ var brightsyAdapter = {
 
 // src/agents/claude.ts
 import { existsSync as existsSync11 } from "fs";
+
+// src/mcp-ui/host.ts
+import { createHash } from "crypto";
 import { homedir as homedir5 } from "os";
 
 // src/agents/orch-mcp-isolation.ts
@@ -458,6 +461,20 @@ import { homedir } from "os";
 import { isAbsolute, join, relative, resolve } from "path";
 
 // src/mcp-ui/meta.ts
+var HTML_MAX = 15e5;
+function matchClaudeMcpTool(toolName, serverNames) {
+  const name = toolName.trim();
+  if (!name.startsWith("mcp__")) return null;
+  const ranked = [...serverNames].filter((s) => s.trim()).sort((a, b) => b.length - a.length);
+  for (const server of ranked) {
+    const prefix = `mcp__${server}__`;
+    if (!name.startsWith(prefix)) continue;
+    const tool = name.slice(prefix.length).trim();
+    if (!tool) continue;
+    return { server, tool };
+  }
+  return null;
+}
 function parseMcpServerLaunch(entry) {
   const command = typeof entry.command === "string" ? entry.command.trim() : "";
   if (command) {
@@ -489,6 +506,105 @@ function parseMcpServerLaunch(entry) {
     ...headers ? { headers } : {}
   };
 }
+function uiResourceUriFromMeta(meta) {
+  const rec = asRecord(meta);
+  const nested = asRecord(rec.ui);
+  const fromNested = typeof nested.resourceUri === "string" ? nested.resourceUri.trim() : "";
+  const legacy = typeof rec["ui/resourceUri"] === "string" ? rec["ui/resourceUri"].trim() : "";
+  const uri = fromNested || legacy;
+  return uri.startsWith("ui://") ? uri : null;
+}
+function cspFromMeta(meta) {
+  const ui = asRecord(asRecord(meta).ui);
+  const csp = asRecord(ui.csp);
+  const connectDomains = originList(csp.connectDomains);
+  const resourceDomains = originList(csp.resourceDomains);
+  const frameDomains = originList(csp.frameDomains);
+  const baseUriDomains = originList(csp.baseUriDomains);
+  if (!connectDomains?.length && !resourceDomains?.length && !frameDomains?.length && !baseUriDomains?.length) {
+    return void 0;
+  }
+  return {
+    ...connectDomains?.length ? { connectDomains } : {},
+    ...resourceDomains?.length ? { resourceDomains } : {},
+    ...frameDomains?.length ? { frameDomains } : {},
+    ...baseUriDomains?.length ? { baseUriDomains } : {}
+  };
+}
+function htmlFromResourceContent(content) {
+  const uri = content.uri?.trim() ?? "";
+  if (!uri.startsWith("ui://")) return null;
+  const mimeType = content.mimeType?.trim() || "text/html";
+  if (!isHtmlMime(mimeType)) return null;
+  const html = htmlText(content.text, content.blob);
+  if (!html) return null;
+  return { uri, mimeType, html };
+}
+function mcpUiContentSecurityPolicy(csp) {
+  const resource = (csp?.resourceDomains ?? []).join(" ");
+  const connect = (csp?.connectDomains ?? []).join(" ");
+  const frames = csp?.frameDomains?.length ? csp.frameDomains.join(" ") : "'none'";
+  const base = csp?.baseUriDomains?.length ? csp.baseUriDomains.join(" ") : "'none'";
+  const connectSrc = connect ? `'self' ${connect}`.trim() : "'none'";
+  return [
+    "default-src 'none'",
+    `script-src 'self' 'unsafe-inline' ${resource}`.trim(),
+    `style-src 'self' 'unsafe-inline' ${resource}`.trim(),
+    `img-src 'self' data: ${resource}`.trim(),
+    `font-src 'self' ${resource}`.trim(),
+    `connect-src ${connectSrc}`,
+    `media-src 'self' data: ${resource}`.trim(),
+    `frame-src ${frames}`,
+    `base-uri ${base}`,
+    "object-src 'none'"
+  ].join("; ");
+}
+function htmlText(text, blob) {
+  if (typeof text === "string" && text.trim()) {
+    return text.length <= HTML_MAX ? text : null;
+  }
+  if (typeof blob !== "string" || !blob.trim()) return null;
+  try {
+    const decoded = decodeBase64(blob.trim());
+    if (!decoded.trim() || decoded.length > HTML_MAX) return null;
+    return decoded;
+  } catch {
+    return null;
+  }
+}
+function decodeBase64(blob) {
+  if (typeof Buffer !== "undefined") return Buffer.from(blob, "base64").toString("utf8");
+  const bin = atob(blob);
+  const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function isHtmlMime(mime) {
+  const base = mime.split(";")[0]?.trim().toLowerCase() ?? "";
+  return base === "text/html";
+}
+function originList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const origin = originToken(item);
+    if (origin && !out.includes(origin)) out.push(origin);
+  }
+  return out;
+}
+function originToken(value) {
+  const trimmed = value.trim();
+  if (/^(https?|wss?):\/\/\*\.[a-z0-9.-]+(?::\d+)?$/i.test(trimmed)) return trimmed;
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== "https:" && url.protocol !== "http:" && url.protocol !== "wss:" && url.protocol !== "ws:") {
+      return null;
+    }
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
 function stringRecord(value) {
   const rec = asRecord(value);
   const out = {};
@@ -1620,6 +1736,492 @@ function toCodexUnattendedAppsArgs() {
   ];
 }
 
+// src/mcp-ui/proxy-http.ts
+import { randomBytes, randomUUID } from "crypto";
+import { createServer } from "http";
+import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/mcp-ui/proxy-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp-ui/visibility.ts
+function visibilityFromMeta(meta) {
+  const rec = asRecord2(meta);
+  const ui = asRecord2(rec.ui);
+  const raw = ui.visibility;
+  if (!Array.isArray(raw)) return ["model", "app"];
+  const out = [];
+  for (const item of raw) {
+    if (item !== "model" && item !== "app") continue;
+    if (!out.includes(item)) out.push(item);
+  }
+  return out.length ? out : ["model", "app"];
+}
+function toolVisibleTo(visibility, audience) {
+  const vis = visibility?.length ? visibility : ["model", "app"];
+  return vis.includes(audience);
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+
+// src/mcp-ui/proxy-server.ts
+function attachMcpUiProxyHandlers(server, session) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = await session.listTools();
+    return { tools: tools.filter((tool) => toolVisibleTo(tool.visibility, "model")).map(listedTool) };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const name = request.params.name;
+    const tools = await session.listTools();
+    const tool = tools.find((item) => item.name === name);
+    if (!tool || !toolVisibleTo(tool.visibility, "model")) {
+      throw new Error(`Tool ${name} is not available to the model`);
+    }
+    return await session.callTool(name, request.params.arguments ?? {});
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const resource = await session.readResource(request.params.uri);
+    if (!resource) throw new Error(`Resource ${request.params.uri} was empty`);
+    return {
+      contents: [
+        {
+          uri: resource.uri,
+          ...resource.mimeType ? { mimeType: resource.mimeType } : {},
+          ...resource.text != null ? { text: resource.text } : {},
+          ...resource.blob != null ? { blob: resource.blob } : {}
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => session.listResources());
+  server.setRequestHandler(
+    ListResourceTemplatesRequestSchema,
+    async () => session.listResourceTemplates()
+  );
+  server.setRequestHandler(ListPromptsRequestSchema, async () => session.listPrompts());
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    return await session.getPrompt(request.params.name, request.params.arguments);
+  });
+  server.fallbackRequestHandler = async (request) => {
+    return await session.forward(request.method, request.params);
+  };
+}
+function listedTool(tool) {
+  return {
+    name: tool.name,
+    ...tool.description ? { description: tool.description } : {},
+    inputSchema: tool.inputSchema ?? { type: "object", properties: {} },
+    _meta: {
+      ui: {
+        ...tool.resourceUri ? { resourceUri: tool.resourceUri } : {},
+        visibility: tool.visibility
+      }
+    }
+  };
+}
+
+// src/mcp-ui/proxy-http.ts
+async function listenMcpUiProxy(opts) {
+  const token = randomBytes(24).toString("hex");
+  const transports = /* @__PURE__ */ new Map();
+  const httpServer = createServer((req, res) => {
+    void handle(req, res);
+  });
+  await new Promise((resolve2, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => resolve2());
+  });
+  const addr = httpServer.address();
+  if (!addr || typeof addr === "string") throw new Error("mcp-ui proxy failed to bind");
+  const origin = `http://127.0.0.1:${addr.port}`;
+  async function handle(req, res) {
+    if (req.headers.authorization !== `Bearer ${token}`) {
+      res.writeHead(401).end();
+      return;
+    }
+    const target = parseMcpUiProxyPath(req.url);
+    if (!target) {
+      res.writeHead(404).end();
+      return;
+    }
+    try {
+      const session = await opts.sessionFor(target.server, target.dirsKey);
+      if (!session) {
+        res.writeHead(404).end();
+        return;
+      }
+      const header = req.headers["mcp-session-id"];
+      const sid = typeof header === "string" ? header : "";
+      const sessionKey = `${target.server}:${target.dirsKey}`;
+      let transport = sid ? transports.get(`${sessionKey}:${sid}`) : void 0;
+      if (!transport) {
+        if (req.method !== "POST") {
+          res.writeHead(400).end();
+          return;
+        }
+        const created = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          allowedHosts: ["127.0.0.1", "localhost"],
+          onsessioninitialized: (id) => {
+            transports.set(`${sessionKey}:${id}`, created);
+          },
+          onsessionclosed: (id) => {
+            transports.delete(`${sessionKey}:${id}`);
+          }
+        });
+        transport = created;
+        const mcp = new Server2(
+          { name: `sideboard-ui-proxy-${target.server}`, version: "1.0.0" },
+          { capabilities: session.capabilities() }
+        );
+        attachMcpUiProxyHandlers(mcp, session);
+        await mcp.connect(created);
+      }
+      await transport.handleRequest(req, res);
+    } catch {
+      if (!res.headersSent) res.writeHead(500).end();
+    }
+  }
+  return {
+    urlFor(server, dirsKey) {
+      const base = `${origin}/s/${encodeURIComponent(server)}`;
+      return dirsKey ? `${base}/d/${dirsKey}` : base;
+    },
+    headers: { Authorization: `Bearer ${token}` },
+    async close() {
+      await Promise.all([...transports.values()].map((item) => item.close().catch(() => void 0)));
+      transports.clear();
+      await new Promise((resolve2) => httpServer.close(() => resolve2()));
+    }
+  };
+}
+function parseMcpUiProxyPath(url) {
+  const path = (url ?? "").split("?")[0] ?? "";
+  if (!path.startsWith("/s/")) return null;
+  const rest = path.slice(3).replace(/\/$/, "");
+  const split = rest.indexOf("/d/");
+  try {
+    if (split < 0) {
+      const server2 = decodeURIComponent(rest).trim();
+      return server2 ? { server: server2, dirsKey: "" } : null;
+    }
+    const server = decodeURIComponent(rest.slice(0, split)).trim();
+    const dirsKey = rest.slice(split + 3);
+    if (!server || !/^[a-f0-9]{16}$/.test(dirsKey)) return null;
+    return { server, dirsKey };
+  } catch {
+    return null;
+  }
+}
+
+// src/mcp-ui/session.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ResultSchema } from "@modelcontextprotocol/sdk/types.js";
+var REQUEST_TIMEOUT_MS = 2e4;
+async function orEmpty(run2, fallback) {
+  try {
+    return await run2();
+  } catch {
+    return fallback;
+  }
+}
+var UI_CAPABILITIES = {
+  extensions: {
+    "io.modelcontextprotocol/ui": {
+      mimeTypes: ["text/html;profile=mcp-app"]
+    }
+  }
+};
+async function openMcpUiSession(launch) {
+  return openMcpUiSessionFromTransport(transportForLaunch(launch));
+}
+async function openMcpUiSessionFromTransport(transport) {
+  const client = new Client(
+    { name: "sideboard", version: "1.0.0" },
+    { capabilities: UI_CAPABILITIES }
+  );
+  await client.connect(transport, { timeout: REQUEST_TIMEOUT_MS });
+  return {
+    async listTools() {
+      const listed = await client.listTools(void 0, { timeout: REQUEST_TIMEOUT_MS });
+      return listed.tools.map((tool) => {
+        const meta = tool._meta;
+        return {
+          name: tool.name,
+          ...tool.description ? { description: tool.description } : {},
+          ...tool.inputSchema ? { inputSchema: tool.inputSchema } : {},
+          resourceUri: uiResourceUriFromMeta(meta),
+          visibility: visibilityFromMeta(meta),
+          ...cspFromMeta(meta) ? { csp: cspFromMeta(meta) } : {}
+        };
+      });
+    },
+    listResources: () => orEmpty(
+      () => client.listResources(void 0, { timeout: REQUEST_TIMEOUT_MS }),
+      { resources: [] }
+    ),
+    listResourceTemplates: () => orEmpty(
+      () => client.listResourceTemplates(void 0, { timeout: REQUEST_TIMEOUT_MS }),
+      { resourceTemplates: [] }
+    ),
+    listPrompts: () => orEmpty(
+      () => client.listPrompts(void 0, { timeout: REQUEST_TIMEOUT_MS }),
+      { prompts: [] }
+    ),
+    getPrompt(name, args) {
+      return client.getPrompt({ name, arguments: args }, { timeout: REQUEST_TIMEOUT_MS });
+    },
+    async readResource(uri) {
+      const result = await client.readResource({ uri }, { timeout: REQUEST_TIMEOUT_MS });
+      const content = result.contents?.[0];
+      if (!content) return null;
+      const text = "text" in content && typeof content.text === "string" ? content.text : void 0;
+      const blob = "blob" in content && typeof content.blob === "string" ? content.blob : void 0;
+      return {
+        uri: content.uri,
+        ...content.mimeType ? { mimeType: content.mimeType } : {},
+        ...text != null ? { text } : {},
+        ...blob != null ? { blob } : {},
+        ...cspFromMeta(content._meta) ? { csp: cspFromMeta(content._meta) } : {}
+      };
+    },
+    async callTool(name, args) {
+      return client.callTool({ name, arguments: args }, void 0, { timeout: REQUEST_TIMEOUT_MS });
+    },
+    capabilities() {
+      const caps = client.getServerCapabilities() ?? {};
+      return {
+        tools: caps.tools ?? {},
+        resources: caps.resources ?? {},
+        prompts: caps.prompts ?? {},
+        completions: caps.completions ?? {},
+        ...caps.logging ? { logging: caps.logging } : {}
+      };
+    },
+    forward(method, params) {
+      return client.request(
+        { method, params },
+        ResultSchema,
+        { timeout: REQUEST_TIMEOUT_MS }
+      );
+    },
+    async close() {
+      await client.close();
+    }
+  };
+}
+function transportForLaunch(launch) {
+  if (launch.kind === "stdio") {
+    return new StdioClientTransport({
+      command: launch.command,
+      args: launch.args,
+      env: { ...getDefaultEnvironment(), ...launch.env },
+      stderr: "ignore",
+      ...launch.cwd ? { cwd: launch.cwd } : {}
+    });
+  }
+  const url = new URL(launch.url);
+  const requestInit = launch.headers ? { headers: launch.headers } : void 0;
+  if (launch.kind === "sse") {
+    return new SSEClientTransport(url, requestInit ? { requestInit } : void 0);
+  }
+  return new StreamableHTTPClientTransport(url, requestInit ? { requestInit } : void 0);
+}
+
+// src/mcp-ui/host.ts
+var TOOL_TTL_MS = 5 * 60 * 1e3;
+var McpUiHost = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  sessions = /* @__PURE__ */ new Map();
+  toolLists = /* @__PURE__ */ new Map();
+  proxy;
+  proxyDirs = /* @__PURE__ */ new Map();
+  async viewForClaudeTool(toolName, projectDirs) {
+    const entries = this.userEntries(projectDirs);
+    const match = matchClaudeMcpTool(toolName, Object.keys(entries));
+    if (!match) return null;
+    const launch = parseMcpServerLaunch(entries[match.server] ?? {});
+    if (!launch) return null;
+    try {
+      const session = await this.sessionFor(match.server, launch);
+      const tools = await this.toolsFor(match.server, launch, session);
+      const tool = tools.find((item) => item.name === match.tool);
+      if (!tool?.resourceUri) return null;
+      const resource = await session.readResource(tool.resourceUri);
+      if (!resource) return null;
+      const html = htmlFromResourceContent(resource);
+      if (!html) return null;
+      const csp = resource.csp ?? tool.csp;
+      return {
+        server: match.server,
+        tool: match.tool,
+        uri: html.uri,
+        mimeType: html.mimeType,
+        html: html.html,
+        csp: mcpUiContentSecurityPolicy(csp)
+      };
+    } catch (err) {
+      console.error(
+        `[mcp-ui] ${match.server}/${match.tool}:`,
+        err instanceof Error ? err.message : err
+      );
+      return null;
+    }
+  }
+  /**
+   * Point Claude at loopback HTTP so it shares this host's upstream session
+   * and never sees `visibility: ["app"]` tools.
+   */
+  async proxyEntries(entries, projectDirs) {
+    const names = Object.keys(entries).filter((name) => name.trim());
+    if (names.length === 0) return {};
+    const dirsKey = dirsKeyFor(projectDirs);
+    this.proxyDirs.set(dirsKey, projectDirs);
+    try {
+      const listen = await this.ensureProxy();
+      const out = {};
+      for (const name of names) {
+        out[name] = {
+          type: "http",
+          url: listen.urlFor(name, dirsKey),
+          headers: listen.headers
+        };
+      }
+      return out;
+    } catch (err) {
+      console.error("[mcp-ui] proxy:", err instanceof Error ? err.message : err);
+      return { ...entries };
+    }
+  }
+  async callTool(server, tool, args, projectDirs) {
+    const entry = this.userEntries(projectDirs)[server];
+    if (!entry) throw new Error(`MCP server ${server} is not available`);
+    const launch = parseMcpServerLaunch(entry);
+    if (!launch) throw new Error(`MCP server ${server} is not available`);
+    const session = await this.sessionFor(server, launch);
+    const tools = await this.toolsFor(server, launch, session);
+    const info = tools.find((item) => item.name === tool);
+    if (!info || !toolVisibleTo(info.visibility, "app")) {
+      throw new Error(`Tool ${tool} is not available to the app`);
+    }
+    return session.callTool(tool, args);
+  }
+  async readResource(server, uri, projectDirs) {
+    const session = await this.sessionForName(server, projectDirs);
+    if (!session) throw new Error(`MCP server ${server} is not available`);
+    const resource = await session.readResource(uri);
+    if (!resource) throw new Error(`Resource ${uri} was empty`);
+    return {
+      contents: [
+        {
+          uri: resource.uri,
+          ...resource.mimeType ? { mimeType: resource.mimeType } : {},
+          ...resource.text != null ? { text: resource.text } : {},
+          ...resource.blob != null ? { blob: resource.blob } : {}
+        }
+      ]
+    };
+  }
+  async closeAll() {
+    const pending = [...this.sessions.values()];
+    const proxy = this.proxy;
+    this.sessions.clear();
+    this.toolLists.clear();
+    this.proxyDirs.clear();
+    this.proxy = void 0;
+    await Promise.all([
+      ...pending.map((session) => session.then((open) => open.close()).catch(() => void 0)),
+      proxy ? proxy.then((listen) => listen.close()).catch(() => void 0) : Promise.resolve()
+    ]);
+  }
+  ensureProxy() {
+    if (this.proxy) return this.proxy;
+    this.proxy = listenMcpUiProxy({
+      sessionFor: (server, dirsKey) => {
+        if (dirsKey && !this.proxyDirs.has(dirsKey)) return Promise.resolve(null);
+        return this.sessionForName(server, this.proxyDirs.get(dirsKey));
+      }
+    }).catch((err) => {
+      this.proxy = void 0;
+      throw err;
+    });
+    return this.proxy;
+  }
+  userEntries(projectDirs) {
+    const out = {};
+    for (const [name, entry] of Object.entries(this.opts.entries(projectDirs))) {
+      if (!name.trim() || isInjectedOrchMcpName(name) || !entry) continue;
+      out[name] = entry;
+    }
+    return out;
+  }
+  async sessionForName(server, projectDirs) {
+    const entry = this.userEntries(projectDirs)[server];
+    if (!entry) return null;
+    const launch = parseMcpServerLaunch(entry);
+    if (!launch) return null;
+    return this.sessionFor(server, launch);
+  }
+  sessionFor(server, launch) {
+    const key = `${server}
+${JSON.stringify(launch)}`;
+    const existing = this.sessions.get(key);
+    if (existing) return existing;
+    const open = this.opts.openSession ?? openMcpUiSession;
+    const pending = open(launch).catch((err) => {
+      this.sessions.delete(key);
+      throw err;
+    });
+    this.sessions.set(key, pending);
+    return pending;
+  }
+  async toolsFor(server, launch, session) {
+    const key = `${server}
+${JSON.stringify(launch)}`;
+    const cached = this.toolLists.get(key);
+    if (cached && cached.key === key && Date.now() - cached.at < TOOL_TTL_MS) return cached.tools;
+    const tools = await session.listTools();
+    this.toolLists.set(key, { at: Date.now(), key, tools });
+    return tools;
+  }
+};
+var singleton;
+function getMcpUiHost() {
+  if (!singleton) {
+    singleton = new McpUiHost({
+      entries: (projectDirs) => listUserClaudeMcpServerEntries(homedir5(), projectDirs)
+    });
+  }
+  return singleton;
+}
+async function proxyClaudeUserMcp(orchestrator, projectDirs) {
+  if (orchestrator) return {};
+  const dirs = projectDirs.filter((d) => typeof d === "string" && d.length > 0);
+  return getMcpUiHost().proxyEntries(listUserClaudeMcpServerEntries(homedir5(), dirs), dirs);
+}
+function dirsKeyFor(projectDirs) {
+  if (!projectDirs?.length) return "";
+  return createHash("sha256").update(projectDirs.join("\0")).digest("hex").slice(0, 16);
+}
+
 // src/agents/types.ts
 var PLAN_MODE_INSTRUCTION = "Plan mode is active and must remain active until the user turns Plan mode off in the UI (or Approves / Hands off the plan). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any project files except via Sideboard MCP present_plan (writes .context/attachments/plan.md). When you need a clarifying decision (approach forks, auth choice, scope) \u2014 not greetings, check-ins, or an invented task menu: (1) first write a short chat message that explains the decision and what each option means (tradeoffs, when to pick it) \u2014 do not leave the user staring at bare labels; (2) then call Sideboard MCP ask_user with the same options, including a description on every option. If one option is the obvious default, proceed without asking. Sideboard shows questions in the composer and mirrors them in chat. After ask_user, wait for the user's next message with their answers before finalizing the plan. When the plan is ready for approval: (1) call present_plan with the full markdown plan (title + content) so Sideboard saves .context/attachments/plan.md and shows it in chat for Approve / Hand off / Copy; (2) Claude should also call ExitPlanMode after present_plan. Do not skip present_plan \u2014 the plan must be a markdown file, not only chat prose.";
 var PLAN_MODE_OFF_INSTRUCTION = "Plan mode is off. Do not call present_plan or ExitPlanMode \u2014 those only work when the user turns Plan on in the composer. If you need to propose an approach, write it in chat.";
@@ -2264,7 +2866,7 @@ var claudeAdapter = {
     });
     const injectedBrightsyNames = injectedServers.filter((s) => s.name === "brightsy" || s.name.startsWith("brightsy_")).map((s) => s.name);
     const chromeOn = claudeChromeEnabled();
-    const userMcpEntries = isOrchestrator ? {} : listUserClaudeMcpServerEntries(homedir5(), [thread.repoPath, thread.worktreePath]);
+    const userMcpEntries = await proxyClaudeUserMcp(isOrchestrator, [thread.repoPath, thread.worktreePath]);
     let allowedTools;
     if (isOrchestrator) {
       allowedTools = [
@@ -2602,7 +3204,7 @@ function unwrapCodexMcpResult(result) {
     return String(result);
   }
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
@@ -2755,7 +3357,7 @@ var codexAdapter = {
         }
         if (itemType === "mcp_tool_call" && item.id && item.server && item.tool) {
           const name = `mcp__${item.server}__${item.tool}`;
-          const input = asRecord2(item.arguments);
+          const input = asRecord3(item.arguments);
           const events = [
             { type: "tool_use", id: item.id, name, input }
           ];
@@ -3056,20 +3658,20 @@ function turnCostUsdFromCursorUsage(before, after) {
   if (!(delta >= 0) || !Number.isFinite(delta)) return void 0;
   return delta / 100;
 }
-function asRecord3(value) {
+function asRecord4(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
   return void 0;
 }
 function normalizeCursorToolCall(name, args) {
-  const raw = asRecord3(args);
+  const raw = asRecord4(args);
   const toolName = typeof raw?.toolName === "string" && raw.toolName.trim() ? raw.toolName.trim() : null;
-  const looksLikeMcp = name === "mcp" || toolName != null && (typeof raw?.providerIdentifier === "string" || asRecord3(raw?.args) != null);
+  const looksLikeMcp = name === "mcp" || toolName != null && (typeof raw?.providerIdentifier === "string" || asRecord4(raw?.args) != null);
   if (looksLikeMcp && toolName) {
     const providerRaw = typeof raw.providerIdentifier === "string" && raw.providerIdentifier.trim() ? raw.providerIdentifier.trim() : "sideboard";
     const provider = providerRaw.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const nested = asRecord3(raw.args);
+    const nested = asRecord4(raw.args);
     return {
       name: `mcp__${provider}__${toolName}`,
       input: nested ?? { toolName }
@@ -3080,7 +3682,7 @@ function normalizeCursorToolCall(name, args) {
 function unwrapCursorToolResult(result) {
   if (result == null) return void 0;
   if (typeof result === "string") return result;
-  const rec = asRecord3(result);
+  const rec = asRecord4(result);
   if (!rec) {
     try {
       return JSON.stringify(result);
@@ -3091,18 +3693,18 @@ function unwrapCursorToolResult(result) {
   const collectTexts = (items) => {
     const texts = [];
     for (const item of items) {
-      const row = asRecord3(item);
+      const row = asRecord4(item);
       if (!row) continue;
       if (typeof row.text === "string") {
         texts.push(row.text);
         continue;
       }
-      const nested = asRecord3(row.text);
+      const nested = asRecord4(row.text);
       if (typeof nested?.text === "string") texts.push(nested.text);
     }
     return texts;
   };
-  const value = asRecord3(rec.value);
+  const value = asRecord4(rec.value);
   if (value && Array.isArray(value.content)) {
     const texts = collectTexts(value.content);
     if (texts.length) return texts.join("\n");
@@ -3119,10 +3721,10 @@ function unwrapCursorToolResult(result) {
 }
 function cursorToolResultIsError(status, result) {
   if (status === "error") return true;
-  const rec = asRecord3(result);
+  const rec = asRecord4(result);
   if (!rec) return false;
   if (rec.status === "error") return true;
-  const value = asRecord3(rec.value);
+  const value = asRecord4(rec.value);
   return value?.isError === true;
 }
 function cursorSdkMessageToEvents(msg) {
@@ -3623,7 +4225,7 @@ var FALLBACK_OPENCODE_MODELS = [
 ];
 var cachedOpencodeModels = null;
 var OPENCODE_MODEL_CACHE_MS = 5 * 60 * 1e3;
-function asRecord4(value) {
+function asRecord5(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
@@ -3794,7 +4396,7 @@ var opencodeAdapter = {
         const name = part?.tool ?? part?.name ?? obj.tool ?? obj.name ?? "tool";
         const state = part?.state;
         const input = (state?.input && typeof state.input === "object" ? state.input : void 0) ?? part?.input ?? obj.input;
-        const metadata = asRecord4(state?.metadata);
+        const metadata = asRecord5(state?.metadata);
         const id = opencodeToolId(
           name,
           part?.callID ?? part?.id ?? obj.id,
@@ -3829,7 +4431,7 @@ var opencodeAdapter = {
       }
       if (obj.type === "subtask_event") {
         const parentId = str(obj.childSessionID) ?? str(obj.childSessionId);
-        const part = asRecord4(obj.part);
+        const part = asRecord5(obj.part);
         if (!parentId || !part) return null;
         if (part.type === "text" && str(part.text)) {
           return withTaskParent(
@@ -3840,8 +4442,8 @@ var opencodeAdapter = {
         if (part.type === "tool" || str(part.tool)) {
           const name = str(part.tool) ?? str(part.name) ?? "tool";
           const id = str(part.callID) ?? str(part.id) ?? `${parentId}-${name}`;
-          const state = asRecord4(part.state);
-          const input = asRecord4(state?.input) ?? asRecord4(part.input);
+          const state = asRecord5(part.state);
+          const input = asRecord5(state?.input) ?? asRecord5(part.input);
           const nested = [
             withEventParentId({ type: "tool_use", id, name, input }, parentId)
           ];