@sideboard-ai/core 0.1.311 → 0.1.313

package/dist/mcp/run-stdio.cjs

@@ -10516,24 +10516,47 @@ var init_turn_trace = __esm({
 });
 
 // src/brightsy/config.ts
+function resolveBrightsyConfigFile(path) {
+  try {
+    if ((0, import_node_fs23.existsSync)(path) && (0, import_node_fs23.statSync)(path).isDirectory()) {
+      return (0, import_node_path26.join)(path, "config.json");
+    }
+  } catch {
+  }
+  return path;
+}
 function brightsyConfigPath() {
   const override = process.env.BRIGHTSY_CONFIG?.trim();
-  if (override) return override;
-  return (0, import_node_path26.join)((0, import_node_os9.homedir)(), ".brightsy", "config.json");
+  const raw = override || (0, import_node_path26.join)((0, import_node_os9.homedir)(), ".brightsy", "config.json");
+  return resolveBrightsyConfigFile(raw);
 }
 function loadBrightsyConfig() {
   const path = brightsyConfigPath();
   if (!(0, import_node_fs23.existsSync)(path)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs23.readFileSync)(path, "utf8"));
+  let text7;
+  try {
+    text7 = (0, import_node_fs23.readFileSync)(path, "utf8");
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+    if (code === "EISDIR") {
+      throw new Error(
+        `Brightsy config is a directory (${path}) \u2014 expected ~/.brightsy/config.json`
+      );
+    }
+    throw err;
+  }
+  const raw = JSON.parse(text7);
   if (!raw.access_token || !raw.account_id) {
     throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
   }
   return raw;
 }
 function saveBrightsyConfig(cfg) {
-  (0, import_node_fs23.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  const path = brightsyConfigPath();
+  (0, import_node_fs23.mkdirSync)((0, import_node_path26.dirname)(path), { recursive: true });
+  (0, import_node_fs23.writeFileSync)(path, `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
@@ -10788,6 +10811,25 @@ function listConnectedBrightsyTeams() {
     expires_at
   }));
 }
+function teamFromCliSession(cfg, current) {
+  return {
+    ...current,
+    access_token: cfg.access_token,
+    refresh_token: cfg.refresh_token ?? current.refresh_token,
+    expires_at: cfg.expires_at ?? current.expires_at,
+    endpoint: cfg.endpoint ?? current.endpoint,
+    oauth_client_id: cfg.oauth_client_id ?? current.oauth_client_id,
+    slug: cfg.account_slug || current.slug
+  };
+}
+function brightsySessionShouldReplace(a, b) {
+  if (!a.access_token) return false;
+  const aStale = brightsyAccessTokenNeedsRefresh(a.expires_at);
+  const bStale = !b.access_token || brightsyAccessTokenNeedsRefresh(b.expires_at);
+  if (!aStale && bStale) return true;
+  if (aStale) return false;
+  return (a.expires_at ?? 0) > (b.expires_at ?? 0);
+}
 function applyConnectedTeamToCli(team) {
   let base = {};
   try {
@@ -10874,22 +10916,34 @@ async function ensureConnectedBrightsyTeamTokens(opts) {
     }
     next.push(refreshed);
   }
-  if (changed) writeStore(next);
   try {
     const cfg2 = loadBrightsyConfig();
-    const active = next.find((t) => t.id === cfg2.account_id);
-    if (active && active.access_token !== cfg2.access_token) {
-      applyConnectedTeamToCli(active);
+    const idx = next.findIndex((t) => t.id === cfg2.account_id);
+    if (idx >= 0) {
+      const active = next[idx];
+      if (brightsySessionShouldReplace(cfg2, active)) {
+        next[idx] = teamFromCliSession(cfg2, active);
+        changed = true;
+      } else if (active.access_token !== cfg2.access_token) {
+        applyConnectedTeamToCli(active);
+      }
     }
   } catch {
   }
+  if (changed) writeStore(next);
   return next;
 }
 function ensureCliTeamTracked(meta) {
   try {
     const cfg = loadBrightsyConfig();
     const existing = readStore();
-    if (existing.some((t) => t.id === cfg.account_id)) {
+    const idx = existing.findIndex((t) => t.id === cfg.account_id);
+    if (idx >= 0) {
+      const current = existing[idx];
+      if (brightsySessionShouldReplace(cfg, current)) {
+        existing[idx] = teamFromCliSession(cfg, current);
+        writeStore(existing);
+      }
       return listConnectedBrightsyTeams();
     }
     const team = {
@@ -11332,6 +11386,19 @@ var init_brightsy = __esm({
 });
 
 // src/mcp-ui/meta.ts
+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) {
@@ -11363,6 +11430,105 @@ function parseMcpServerLaunch(entry) {
     ...headers ? { headers } : {}
   };
 }
+function uiResourceUriFromMeta(meta) {
+  const rec = asRecord3(meta);
+  const nested = asRecord3(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 = asRecord3(asRecord3(meta).ui);
+  const csp = asRecord3(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(text7, blob) {
+  if (typeof text7 === "string" && text7.trim()) {
+    return text7.length <= HTML_MAX ? text7 : 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 = asRecord3(value);
   const out = {};
@@ -11375,9 +11541,11 @@ function asRecord3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
   return value;
 }
+var HTML_MAX;
 var init_meta = __esm({
   "src/mcp-ui/meta.ts"() {
     "use strict";
+    HTML_MAX = 15e5;
   }
 });
 
@@ -12416,6 +12584,519 @@ var init_orch_mcp_isolation = __esm({
   }
 });
 
+// src/mcp-ui/visibility.ts
+function visibilityFromMeta(meta) {
+  const rec = asRecord4(meta);
+  const ui = asRecord4(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 asRecord4(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+var init_visibility = __esm({
+  "src/mcp-ui/visibility.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp-ui/proxy-server.ts
+function attachMcpUiProxyHandlers(server, session) {
+  server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+    const tools = await session.listTools();
+    return { tools: tools.filter((tool) => toolVisibleTo(tool.visibility, "model")).map(listedTool) };
+  });
+  server.setRequestHandler(import_types.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(import_types.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(import_types.ListResourcesRequestSchema, async () => session.listResources());
+  server.setRequestHandler(
+    import_types.ListResourceTemplatesRequestSchema,
+    async () => session.listResourceTemplates()
+  );
+  server.setRequestHandler(import_types.ListPromptsRequestSchema, async () => session.listPrompts());
+  server.setRequestHandler(import_types.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
+      }
+    }
+  };
+}
+var import_server, import_types;
+var init_proxy_server = __esm({
+  "src/mcp-ui/proxy-server.ts"() {
+    "use strict";
+    import_server = require("@modelcontextprotocol/sdk/server/index.js");
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+    init_visibility();
+  }
+});
+
+// src/mcp-ui/proxy-http.ts
+async function listenMcpUiProxy(opts) {
+  const token = (0, import_node_crypto6.randomBytes)(24).toString("hex");
+  const transports = /* @__PURE__ */ new Map();
+  const httpServer = (0, import_node_http.createServer)((req, res) => {
+    void handle(req, res);
+  });
+  await new Promise((resolve3, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => resolve3());
+  });
+  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 import_streamableHttp.StreamableHTTPServerTransport({
+          sessionIdGenerator: () => (0, import_node_crypto6.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 import_server2.Server(
+          { 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((resolve3) => httpServer.close(() => resolve3()));
+    }
+  };
+}
+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;
+  }
+}
+var import_node_crypto6, import_node_http, import_server2, import_streamableHttp;
+var init_proxy_http = __esm({
+  "src/mcp-ui/proxy-http.ts"() {
+    "use strict";
+    import_node_crypto6 = require("crypto");
+    import_node_http = require("http");
+    import_server2 = require("@modelcontextprotocol/sdk/server/index.js");
+    import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    init_proxy_server();
+  }
+});
+
+// src/mcp-ui/session.ts
+async function orEmpty(run2, fallback) {
+  try {
+    return await run2();
+  } catch {
+    return fallback;
+  }
+}
+async function openMcpUiSession(launch) {
+  return openMcpUiSessionFromTransport(transportForLaunch(launch));
+}
+async function openMcpUiSessionFromTransport(transport) {
+  const client = new import_client.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 text7 = "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 } : {},
+        ...text7 != null ? { text: text7 } : {},
+        ...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 },
+        import_types2.ResultSchema,
+        { timeout: REQUEST_TIMEOUT_MS }
+      );
+    },
+    async close() {
+      await client.close();
+    }
+  };
+}
+function transportForLaunch(launch) {
+  if (launch.kind === "stdio") {
+    return new import_stdio.StdioClientTransport({
+      command: launch.command,
+      args: launch.args,
+      env: { ...(0, import_stdio.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 import_sse.SSEClientTransport(url, requestInit ? { requestInit } : void 0);
+  }
+  return new import_streamableHttp2.StreamableHTTPClientTransport(url, requestInit ? { requestInit } : void 0);
+}
+var import_client, import_sse, import_stdio, import_streamableHttp2, import_types2, REQUEST_TIMEOUT_MS, UI_CAPABILITIES;
+var init_session = __esm({
+  "src/mcp-ui/session.ts"() {
+    "use strict";
+    import_client = require("@modelcontextprotocol/sdk/client/index.js");
+    import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+    import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+    import_streamableHttp2 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    import_types2 = require("@modelcontextprotocol/sdk/types.js");
+    init_meta();
+    init_visibility();
+    REQUEST_TIMEOUT_MS = 2e4;
+    UI_CAPABILITIES = {
+      extensions: {
+        "io.modelcontextprotocol/ui": {
+          mimeTypes: ["text/html;profile=mcp-app"]
+        }
+      }
+    };
+  }
+});
+
+// src/mcp-ui/host.ts
+function getMcpUiHost() {
+  if (!singleton) {
+    singleton = new McpUiHost({
+      entries: (projectDirs) => listUserClaudeMcpServerEntries((0, import_node_os15.homedir)(), 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((0, import_node_os15.homedir)(), dirs), dirs);
+}
+function dirsKeyFor(projectDirs) {
+  if (!projectDirs?.length) return "";
+  return (0, import_node_crypto7.createHash)("sha256").update(projectDirs.join("\0")).digest("hex").slice(0, 16);
+}
+var import_node_crypto7, import_node_os15, TOOL_TTL_MS, McpUiHost, singleton;
+var init_host = __esm({
+  "src/mcp-ui/host.ts"() {
+    "use strict";
+    import_node_crypto7 = require("crypto");
+    import_node_os15 = require("os");
+    init_orch_mcp_isolation();
+    init_meta();
+    init_proxy_http();
+    init_session();
+    init_visibility();
+    TOOL_TTL_MS = 5 * 60 * 1e3;
+    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;
+      }
+    };
+  }
+});
+
 // src/agents/types.ts
 function planModeTurnInstruction(planMode) {
   return planMode ? PLAN_MODE_INSTRUCTION : PLAN_MODE_OFF_INSTRUCTION;
@@ -12596,7 +13277,7 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path35.dirname)((0, import_node_url2.fileURLToPath)(import_meta3.url));
+    return (0, import_node_path35.dirname)((0, import_node_url2.fileURLToPath)(import_meta5.url));
   } catch {
     try {
       const req = (0, import_node_module2.createRequire)(process.cwd() + "/");
@@ -12646,7 +13327,7 @@ async function buildClaudeRpcTurnCommand(req) {
     }
   };
 }
-var import_node_fs33, import_node_module2, import_node_path35, import_node_url2, import_meta3;
+var import_node_fs33, import_node_module2, import_node_path35, import_node_url2, import_meta5;
 var init_claude_host = __esm({
   "src/agents/claude-host.ts"() {
     "use strict";
@@ -12658,7 +13339,7 @@ var init_claude_host = __esm({
     init_pilot_tools();
     init_node_launch();
     init_packaged_runtime();
-    import_meta3 = {};
+    import_meta5 = {};
   }
 });
 
@@ -13061,16 +13742,15 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs34, import_node_os15, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs34, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
     import_node_fs34 = require("fs");
-    import_node_os15 = require("os");
     init_run();
     init_app_settings();
     init_claude_mcp();
-    init_orch_mcp_isolation();
+    init_host();
     init_error_detail();
     init_message_parts();
     init_injected_mcp();
@@ -13147,7 +13827,7 @@ var init_claude = __esm({
         });
         const injectedBrightsyNames = injectedServers.filter((s) => s.name === "brightsy" || s.name.startsWith("brightsy_")).map((s) => s.name);
         const chromeOn = claudeChromeEnabled();
-        const userMcpEntries = isOrchestrator ? {} : listUserClaudeMcpServerEntries((0, import_node_os15.homedir)(), [thread.repoPath, thread.worktreePath]);
+        const userMcpEntries = await proxyClaudeUserMcp(isOrchestrator, [thread.repoPath, thread.worktreePath]);
         let allowedTools;
         if (isOrchestrator) {
           allowedTools = [
@@ -13449,7 +14129,7 @@ function unwrapCodexMcpResult(result) {
     return String(result);
   }
 }
-function asRecord4(value) {
+function asRecord5(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
@@ -13629,7 +14309,7 @@ var init_codex = __esm({
             }
             if (itemType === "mcp_tool_call" && item.id && item.server && item.tool) {
               const name = `mcp__${item.server}__${item.tool}`;
-              const input = asRecord4(item.arguments);
+              const input = asRecord5(item.arguments);
               const events = [
                 { type: "tool_use", id: item.id, name, input }
               ];
@@ -13776,7 +14456,7 @@ function thisModuleFile() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return (0, import_node_path37.join)(cjsDir, "cursor-sdk-resolve.js");
   try {
-    return (0, import_node_url3.fileURLToPath)(import_meta4.url);
+    return (0, import_node_url3.fileURLToPath)(import_meta6.url);
   } catch {
     return (0, import_node_path37.join)(process.cwd(), "package.json");
   }
@@ -13875,7 +14555,7 @@ function cursorSdkRipgrepCandidate(opts) {
   const nested = (0, import_node_path37.join)(root, "node_modules", pkg, "bin", bin);
   return (0, import_node_fs36.existsSync)(nested) ? nested : null;
 }
-var import_node_fs36, import_node_module3, import_node_path37, import_node_url3, import_meta4, CURSOR_SDK_INSTALL_HINT;
+var import_node_fs36, import_node_module3, import_node_path37, import_node_url3, import_meta6, CURSOR_SDK_INSTALL_HINT;
 var init_cursor_sdk_resolve = __esm({
   "src/agents/cursor-sdk-resolve.ts"() {
     "use strict";
@@ -13884,7 +14564,7 @@ var init_cursor_sdk_resolve = __esm({
     import_node_path37 = require("path");
     import_node_url3 = require("url");
     init_path();
-    import_meta4 = {};
+    import_meta6 = {};
     CURSOR_SDK_INSTALL_HINT = "Cursor SDK is not installed. Settings \u2192 Agents \u2192 Cursor \u2192 Install (`npm i -g @cursor/sdk`). Sideboard does not ship the SDK \u2014 update it anytime without a new Sideboard build.";
   }
 });
@@ -14019,7 +14699,7 @@ function entryDir2() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path39.dirname)((0, import_node_url4.fileURLToPath)(import_meta5.url));
+    return (0, import_node_path39.dirname)((0, import_node_url4.fileURLToPath)(import_meta7.url));
   } catch {
     try {
       const req = (0, import_node_module5.createRequire)(process.cwd() + "/");
@@ -14048,7 +14728,7 @@ function cursorRunnerPath() {
   }
   return candidates[0];
 }
-var import_node_fs38, import_node_module5, import_node_path39, import_node_url4, import_meta5, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs38, import_node_module5, import_node_path39, import_node_url4, import_meta7, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
 var init_cursor = __esm({
   "src/agents/cursor.ts"() {
     "use strict";
@@ -14068,7 +14748,7 @@ var init_cursor = __esm({
     init_packaged_runtime();
     init_turn_input();
     init_cursor_events();
-    import_meta5 = {};
+    import_meta7 = {};
     FALLBACK_CURSOR_MODELS = [
       { id: "default", displayName: "Auto" },
       { id: "composer-2.5", displayName: "Composer 2.5" },
@@ -14342,7 +15022,7 @@ var init_opencode_host = __esm({
 });
 
 // src/agents/opencode.ts
-function asRecord5(value) {
+function asRecord6(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
@@ -14538,7 +15218,7 @@ var init_opencode = __esm({
             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 = asRecord5(state?.metadata);
+            const metadata = asRecord6(state?.metadata);
             const id = opencodeToolId(
               name,
               part?.callID ?? part?.id ?? obj.id,
@@ -14573,7 +15253,7 @@ var init_opencode = __esm({
           }
           if (obj.type === "subtask_event") {
             const parentId = str3(obj.childSessionID) ?? str3(obj.childSessionId);
-            const part = asRecord5(obj.part);
+            const part = asRecord6(obj.part);
             if (!parentId || !part) return null;
             if (part.type === "text" && str3(part.text)) {
               return withTaskParent(
@@ -14584,8 +15264,8 @@ var init_opencode = __esm({
             if (part.type === "tool" || str3(part.tool)) {
               const name = str3(part.tool) ?? str3(part.name) ?? "tool";
               const id = str3(part.callID) ?? str3(part.id) ?? `${parentId}-${name}`;
-              const state = asRecord5(part.state);
-              const input = asRecord5(state?.input) ?? asRecord5(part.input);
+              const state = asRecord6(part.state);
+              const input = asRecord6(state?.input) ?? asRecord6(part.input);
               const nested = [
                 withEventParentId({ type: "tool_use", id, name, input }, parentId)
               ];
@@ -16361,7 +17041,7 @@ function forkMessageSlice(from, throughIndex) {
 function buildForkTranscriptAttachment(baseTitle, messages) {
   const title = baseTitle || "Chat";
   return {
-    id: (0, import_node_crypto6.randomUUID)(),
+    id: (0, import_node_crypto8.randomUUID)(),
     name: `Transcript of ${title}.md`,
     kind: "transcript",
     content: formatTranscriptMarkdown(title, messages)
@@ -16420,11 +17100,11 @@ function forkChatTab(input) {
   }
   return tab;
 }
-var import_node_crypto6;
+var import_node_crypto8;
 var init_chat_tabs = __esm({
   "src/threads/chat-tabs.ts"() {
     "use strict";
-    import_node_crypto6 = require("crypto");
+    import_node_crypto8 = require("crypto");
     init_context_compact();
     init_teams();
     init_worktree_labels();
@@ -16698,7 +17378,7 @@ function buildReviewRequestAttachment(content, opts) {
   const path = opts?.path ?? REVIEW_SKILL_PATH;
   const name = opts?.name ?? (path === REVIEW_SKILL_PATH ? REVIEW_SKILL_NAME : path === REPO_REVIEW_PATH || path === CONTEXT_REVIEW_PATH ? REPO_REVIEW_NAME : REVIEW_REQUEST_NAME);
   return {
-    id: (0, import_node_crypto7.randomUUID)(),
+    id: (0, import_node_crypto9.randomUUID)(),
     name,
     kind: "file",
     path,
@@ -16751,11 +17431,11 @@ async function requestReview(threadRef, send) {
   const started = await send(tab.id, REVIEW_REQUEST_PREFILL);
   return { tab: started, from };
 }
-var import_node_crypto7, import_node_fs44, import_node_path44, REPO_REVIEW_PATH, REPO_REVIEW_NAME, CONTEXT_REVIEW_PATH, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
+var import_node_crypto9, import_node_fs44, import_node_path44, REPO_REVIEW_PATH, REPO_REVIEW_NAME, CONTEXT_REVIEW_PATH, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
 var init_request_review = __esm({
   "src/review/request-review.ts"() {
     "use strict";
-    import_node_crypto7 = require("crypto");
+    import_node_crypto9 = require("crypto");
     import_node_fs44 = require("fs");
     import_node_path44 = require("path");
     init_global_workspace();
@@ -18013,7 +18693,7 @@ function setupLogPath(threadId) {
 }
 function setupLogKeyForWorktree(worktreePath) {
   const norm = normalizeWorktreePath(worktreePath);
-  return `wt-${(0, import_node_crypto8.createHash)("sha1").update(norm).digest("hex").slice(0, 16)}`;
+  return `wt-${(0, import_node_crypto10.createHash)("sha1").update(norm).digest("hex").slice(0, 16)}`;
 }
 function emptySetupLog() {
   return { ...EMPTY };
@@ -18106,11 +18786,11 @@ function finishSetupLog(threadId, exitCode, source) {
   persistNow(threadId);
   return materialize(mem);
 }
-var import_node_crypto8, import_node_fs48, import_node_path48, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
+var import_node_crypto10, import_node_fs48, import_node_path48, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
 var init_setup_log = __esm({
   "src/store/setup-log.ts"() {
     "use strict";
-    import_node_crypto8 = require("crypto");
+    import_node_crypto10 = require("crypto");
     import_node_fs48 = require("fs");
     import_node_path48 = require("path");
     init_worktree_labels();
@@ -18161,7 +18841,7 @@ function runLogPath(key) {
 }
 function runLogKeyForWorktree(worktreePath, scriptName) {
   const norm = normalizeWorktreePath(worktreePath);
-  const hash = (0, import_node_crypto9.createHash)("sha1").update(norm).digest("hex").slice(0, 16);
+  const hash = (0, import_node_crypto11.createHash)("sha1").update(norm).digest("hex").slice(0, 16);
   return `wt-${hash}-run-${safeScriptToken(scriptName)}`;
 }
 function emptyRunLog() {
@@ -18262,11 +18942,11 @@ function finishRunLog(key, exitCode) {
 function flushRunLog(key) {
   persistNow2(key);
 }
-var import_node_crypto9, import_node_fs49, import_node_path49, EMPTY2, MAX_RUN_LOG_CHARS, DEFAULT_RUN_LOG_TAIL_CHARS, memory2, persistTimers2, PERSIST_DEBOUNCE_MS2;
+var import_node_crypto11, import_node_fs49, import_node_path49, EMPTY2, MAX_RUN_LOG_CHARS, DEFAULT_RUN_LOG_TAIL_CHARS, memory2, persistTimers2, PERSIST_DEBOUNCE_MS2;
 var init_run_log = __esm({
   "src/store/run-log.ts"() {
     "use strict";
-    import_node_crypto9 = require("crypto");
+    import_node_crypto11 = require("crypto");
     import_node_fs49 = require("fs");
     import_node_path49 = require("path");
     init_worktree_labels();
@@ -18657,6 +19337,21 @@ var init_desktop_host = __esm({
   }
 });
 
+// src/mcp-ui/model-context.ts
+function takeMcpAppModelContext(threadId) {
+  const thread = readThread(threadId);
+  const text7 = thread?.mcpAppModelContext?.trim();
+  if (!text7) return void 0;
+  updateThread(threadId, { mcpAppModelContext: null });
+  return text7;
+}
+var init_model_context = __esm({
+  "src/mcp-ui/model-context.ts"() {
+    "use strict";
+    init_thread_store();
+  }
+});
+
 // src/agents/tool-permission.ts
 function setToolPermissionPublisher(next) {
   publisher = next;
@@ -18677,11 +19372,11 @@ function denyPendingToolPermissions(threadId) {
   const last = pending[pending.length - 1];
   if (last) clearPrompt(threadId, last.id);
 }
-var import_node_crypto10, import_node_path53, queues, publisher;
+var import_node_crypto12, import_node_path53, queues, publisher;
 var init_tool_permission = __esm({
   "src/agents/tool-permission.ts"() {
     "use strict";
-    import_node_crypto10 = require("crypto");
+    import_node_crypto12 = require("crypto");
     import_node_path53 = require("path");
     init_claude_mcp();
     queues = /* @__PURE__ */ new Map();
@@ -18739,7 +19434,7 @@ var init_agent_block_view = __esm({
 });
 
 // src/plan/plan-present.ts
-function asRecord6(v) {
+function asRecord7(v) {
   return v != null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
 function isPresentPlanToolName(name) {
@@ -18758,7 +19453,7 @@ function extractPresentedPlan(parts) {
   for (let i = parts.length - 1; i >= 0; i--) {
     const p = parts[i];
     if (p.type !== "tool" || !isPresentPlanToolName(p.name)) continue;
-    const input = asRecord6(p.input) ?? {};
+    const input = asRecord7(p.input) ?? {};
     const content = typeof input.content === "string" ? input.content : typeof input.plan === "string" ? input.plan : typeof input.markdown === "string" ? input.markdown : "";
     if (!content.trim()) continue;
     const title = typeof input.title === "string" && input.title.trim() ? input.title.trim() : "Plan";
@@ -19213,7 +19908,7 @@ function isUnclaimedSteerRequest(req) {
 }
 function nextSteerRequest(existing) {
   if (existing?.requestId && !existing.claimedAt) return existing;
-  return { requestId: (0, import_node_crypto11.randomUUID)(), requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  return { requestId: (0, import_node_crypto13.randomUUID)(), requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 function claimSteerRequest(threadId) {
   const pending = readThread(threadId)?.steerRequest;
@@ -19222,11 +19917,11 @@ function claimSteerRequest(threadId) {
     steerRequest: { ...pending, claimedAt: (/* @__PURE__ */ new Date()).toISOString() }
   });
 }
-var import_node_crypto11;
+var import_node_crypto13;
 var init_steer_request = __esm({
   "src/orchestrator/steer-request.ts"() {
     "use strict";
-    import_node_crypto11 = require("crypto");
+    import_node_crypto13 = require("crypto");
     init_thread_store();
   }
 });
@@ -19998,8 +20693,8 @@ function resolveAbleTimeOAuthHost(requested, saved) {
   return fromSaved || void 0;
 }
 function createAbleTimePkce() {
-  const verifier = (0, import_node_crypto12.randomBytes)(32).toString("base64url");
-  const challenge = (0, import_node_crypto12.createHash)("sha256").update(verifier).digest("base64url");
+  const verifier = (0, import_node_crypto14.randomBytes)(32).toString("base64url");
+  const challenge = (0, import_node_crypto14.createHash)("sha256").update(verifier).digest("base64url");
   return { verifier, challenge };
 }
 function ableTimeOAuthAuthorizeUrl(clientId, state, codeChallenge, host) {
@@ -20104,7 +20799,7 @@ async function startAbleTimeOAuth(opts) {
     opts?.host,
     loadAppSettings().integrations.abletimeHost
   );
-  const state = (0, import_node_crypto12.randomBytes)(16).toString("hex");
+  const state = (0, import_node_crypto14.randomBytes)(16).toString("hex");
   const pkce = createAbleTimePkce();
   const authorizeUrl = ableTimeOAuthAuthorizeUrl(clientId, state, pkce.challenge, host);
   const timeoutMs = opts?.timeoutMs ?? 5 * 6e4;
@@ -20117,7 +20812,7 @@ async function startAbleTimeOAuth(opts) {
       if (err) reject(err);
       else resolve3(value);
     };
-    const server = (0, import_node_http.createServer)((req, res) => {
+    const server = (0, import_node_http2.createServer)((req, res) => {
       try {
         const url = new URL(req.url || "/", `http://127.0.0.1:${ABLETIME_OAUTH_PORT}`);
         if (url.pathname !== "/callback") {
@@ -20204,12 +20899,12 @@ async function startAbleTimeOAuth(opts) {
     return loadAppSettings();
   }
 }
-var import_node_crypto12, import_node_http, ABLETIME_OAUTH_CALLBACK_PATH, ABLETIME_OAUTH_PORT, ABLETIME_OAUTH_LOCAL_CALLBACK, ABLETIME_OAUTH_REDIRECT, BOUNCE_QUERY_KEYS, BAKED_ABLETIME_OAUTH_CLIENT_ID, ABLETIME_OAUTH_RESOURCE, REFRESH_SKEW_MS2, refreshInFlight2, ABLETIME_OAUTH_CANCELLED, AbleTimeOAuthCancelledError;
+var import_node_crypto14, import_node_http2, ABLETIME_OAUTH_CALLBACK_PATH, ABLETIME_OAUTH_PORT, ABLETIME_OAUTH_LOCAL_CALLBACK, ABLETIME_OAUTH_REDIRECT, BOUNCE_QUERY_KEYS, BAKED_ABLETIME_OAUTH_CLIENT_ID, ABLETIME_OAUTH_RESOURCE, REFRESH_SKEW_MS2, refreshInFlight2, ABLETIME_OAUTH_CANCELLED, AbleTimeOAuthCancelledError;
 var init_abletime_oauth = __esm({
   "src/integrations/abletime-oauth.ts"() {
     "use strict";
-    import_node_crypto12 = require("crypto");
-    import_node_http = require("http");
+    import_node_crypto14 = require("crypto");
+    import_node_http2 = require("http");
     init_fetch();
     init_app_settings();
     init_abletime_mcp();
@@ -20242,7 +20937,7 @@ __export(abletime_rest_exports, {
   looksLikeAbleTimeUlid: () => looksLikeAbleTimeUlid,
   textFromAbleTimeDoc: () => textFromAbleTimeDoc
 });
-function asRecord7(value) {
+function asRecord8(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function asString(value) {
@@ -20250,7 +20945,7 @@ function asString(value) {
 }
 function asList(value) {
   if (Array.isArray(value)) return value;
-  const record = asRecord7(value);
+  const record = asRecord8(value);
   if (!record) return [];
   for (const key of ["data", "tasks", "projects", "users", "items", "results"]) {
     if (Array.isArray(record[key])) return record[key];
@@ -20267,12 +20962,12 @@ function ableTimeDocFromText(text7) {
 }
 function textFromAbleTimeDoc(value) {
   if (typeof value === "string") return value.trim();
-  const record = asRecord7(value);
+  const record = asRecord8(value);
   if (!record) return "";
   if (typeof record.text === "string" && record.text.trim()) return record.text.trim();
   const chunks = [];
   const walk = (node) => {
-    const rec = asRecord7(node);
+    const rec = asRecord8(node);
     if (!rec) return;
     if (typeof rec.text === "string" && rec.text) chunks.push(rec.text);
     if (Array.isArray(rec.content)) rec.content.forEach(walk);
@@ -20334,7 +21029,7 @@ async function restPages(path, opts, maxPages = 20) {
       query: { ...opts.query, ...cursor ? { cursor } : {} }
     });
     items.push(...asList(raw));
-    const page = asRecord7(asRecord7(raw)?.page);
+    const page = asRecord8(asRecord8(raw)?.page);
     const next = page ? asString(page.nextCursor) : "";
     if (!next) break;
     cursor = next;
@@ -20342,7 +21037,7 @@ async function restPages(path, opts, maxPages = 20) {
   return items;
 }
 function userDisplayName(raw) {
-  const rec = asRecord7(raw);
+  const rec = asRecord8(raw);
   if (!rec) return null;
   const id = asString(rec.userId) || asString(rec.id);
   const name = [asString(rec.firstName), asString(rec.lastName)].filter(Boolean).join(" ") || asString(rec.username) || asString(rec.email) || asString(rec.name);
@@ -20350,7 +21045,7 @@ function userDisplayName(raw) {
   return { id: id || void 0, name };
 }
 function restTaskToRaw(raw, users) {
-  const rec = asRecord7(raw);
+  const rec = asRecord8(raw);
   if (!rec) return null;
   const id = asString(rec.timeflowTaskId) || asString(rec.taskId) || asString(rec.id);
   const identifier = asString(rec.taskRef) || asString(rec.reference) || id;
@@ -20358,7 +21053,7 @@ function restTaskToRaw(raw, users) {
   if (!id && !identifier && !title) return null;
   const assignee = users.get(asString(rec.assignedUserId));
   const comments = asList(rec.comments).map((item) => {
-    const comment = asRecord7(item) ?? {};
+    const comment = asRecord8(item) ?? {};
     const user = userDisplayName(comment);
     return {
       id: asString(comment.commentId) || asString(comment.id),
@@ -20388,13 +21083,13 @@ function restTaskToRaw(raw, users) {
   };
 }
 function restProjectToRaw(raw) {
-  const rec = asRecord7(raw);
+  const rec = asRecord8(raw);
   if (!rec) return null;
   const id = asString(rec.projectId) || asString(rec.id);
   const name = asString(rec.projectName) || asString(rec.name);
   if (!id && !name) return null;
   const categories = asList(rec.categories).map((item) => {
-    const cat = asRecord7(item) ?? {};
+    const cat = asRecord8(item) ?? {};
     return {
       id: asString(cat.projectCategoryId) || asString(cat.categoryId) || asString(cat.id),
       name: asString(cat.categoryName) || asString(cat.name)
@@ -20406,7 +21101,7 @@ async function listUsers(opts) {
   const users = /* @__PURE__ */ new Map();
   for (const item of await restPages("/users", opts).catch(() => [])) {
     const user = userDisplayName(item);
-    const rec = asRecord7(item);
+    const rec = asRecord8(item);
     const id = user?.id || (rec ? asString(rec.userId) : "");
     if (user && id) users.set(id, user);
   }
@@ -20532,10 +21227,10 @@ async function callAbleTimeRestTool(name, args = {}, opts) {
       if (!project) throw new Error("AbleTime has no projects to create a task in");
       const categories = asList(project.categories);
       const wantedCategory = firstStringArg(args, ["category_id", "categoryId", "category"]);
-      const category = categories.map((item) => asRecord7(item)).find((item) => {
+      const category = categories.map((item) => asRecord8(item)).find((item) => {
         if (!item || !wantedCategory) return false;
         return asString(item.id).toLowerCase() === wantedCategory.toLowerCase() || asString(item.name).toLowerCase() === wantedCategory.toLowerCase();
-      }) ?? asRecord7(categories[0]);
+      }) ?? asRecord8(categories[0]);
       const parentArg = firstStringArg(args, ["parent", "parent_id", "parentId", "related_task_id"]);
       const parentTaskId = parentArg ? await resolveRestParentTaskId(parentArg, requestOpts) : void 0;
       const created = await abletimeRestRequest("/tasks", {
@@ -20549,7 +21244,7 @@ async function callAbleTimeRestTool(name, args = {}, opts) {
         }
       });
       const state = firstStringArg(args, ["state"]);
-      const createdId = asString(asRecord7(created)?.timeflowTaskId);
+      const createdId = asString(asRecord8(created)?.timeflowTaskId);
       const description = asString(args.description);
       if (createdId && description) {
         await abletimeRestRequest(`/tasks/${encodeURIComponent(createdId)}`, {
@@ -20622,7 +21317,7 @@ async function callAbleTimeRestTool(name, args = {}, opts) {
         method: "POST",
         body: { content: ableTimeDocFromText(body) }
       });
-      const rec = asRecord7(created) ?? {};
+      const rec = asRecord8(created) ?? {};
       return {
         id: asString(rec.commentId) || void 0,
         body: textFromAbleTimeDoc(rec.content) || body
@@ -20717,7 +21412,7 @@ function rewriteAbleTimeError(message) {
   }
   return message;
 }
-function asRecord8(value) {
+function asRecord9(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function parseSseJson(body) {
@@ -20739,12 +21434,12 @@ function parseSseJson(body) {
   }
 }
 function unwrapToolResult(result) {
-  const record = asRecord8(result);
+  const record = asRecord9(result);
   if (!record) return result;
   const content = record.content;
   if (Array.isArray(content)) {
     const texts = content.map((part) => {
-      const item = asRecord8(part);
+      const item = asRecord9(part);
       if (!item) return "";
       return typeof item.text === "string" ? item.text : "";
     }).filter(Boolean);
@@ -20766,7 +21461,7 @@ function unwrapToolResult(result) {
   return result;
 }
 function textsFromUnknown(value) {
-  const record = asRecord8(value);
+  const record = asRecord9(value);
   if (!record) return "";
   if (typeof record.message === "string") return record.message;
   if (typeof record.error === "string") return record.error;
@@ -20813,7 +21508,7 @@ async function abletimeMcpRequest(method, params, opts) {
       return parseSseJson(body);
     }
   })();
-  const rpc = asRecord8(parsed);
+  const rpc = asRecord9(parsed);
   if (rpc?.error) {
     const detail = typeof rpc.error.message === "string" && rpc.error.message.trim() ? rpc.error.message : `AbleTime MCP error ${rpc.error.code ?? ""}`.trim();
     throw new Error(rewriteAbleTimeError(detail));
@@ -20968,7 +21663,7 @@ function uniqueAttachmentFileName(dir, originalName) {
     const candidate = `${stem}-${i}${ext}`;
     if (!(0, import_node_fs53.existsSync)((0, import_node_path54.join)(dir, candidate))) return candidate;
   }
-  return `${stem}-${(0, import_node_crypto13.randomUUID)()}${ext}`;
+  return `${stem}-${(0, import_node_crypto15.randomUUID)()}${ext}`;
 }
 function extractHttpUrls(markdown) {
   const text7 = markdown ?? "";
@@ -21074,13 +21769,13 @@ async function downloadAuthenticatedFile(opts) {
     ...contentType ? { contentType } : {}
   };
 }
-var import_node_fs53, import_node_path54, import_node_crypto13, ISSUE_ATTACHMENT_MAX_BYTES, MARKDOWN_IMAGE_RE, MARKDOWN_LINK_RE, HTML_SRC_RE, BARE_URL_RE, EXT_BY_MIME;
+var import_node_fs53, import_node_path54, import_node_crypto15, ISSUE_ATTACHMENT_MAX_BYTES, MARKDOWN_IMAGE_RE, MARKDOWN_LINK_RE, HTML_SRC_RE, BARE_URL_RE, EXT_BY_MIME;
 var init_issue_attachments = __esm({
   "src/integrations/issue-attachments.ts"() {
     "use strict";
     import_node_fs53 = require("fs");
     import_node_path54 = require("path");
-    import_node_crypto13 = require("crypto");
+    import_node_crypto15 = require("crypto");
     init_fetch();
     init_workspace_scratch();
     ISSUE_ATTACHMENT_MAX_BYTES = 25 * 1024 * 1024;
@@ -21105,7 +21800,7 @@ var init_issue_attachments = __esm({
 });
 
 // src/integrations/abletime-attachments.ts
-function asRecord9(value) {
+function asRecord10(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function asString2(value) {
@@ -21113,7 +21808,7 @@ function asString2(value) {
 }
 function asList2(value) {
   if (Array.isArray(value)) return value;
-  const record = asRecord9(value);
+  const record = asRecord10(value);
   if (!record) return [];
   for (const key of ["data", "tasks", "projects", "items", "results", "nodes"]) {
     if (Array.isArray(record[key])) return record[key];
@@ -21132,9 +21827,9 @@ function filesFromAbleTimeDoc(value) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const walk = (node) => {
-    const rec = asRecord9(node);
+    const rec = asRecord10(node);
     if (!rec) return;
-    const attrs = asRecord9(rec.attrs) ?? rec;
+    const attrs = asRecord10(rec.attrs) ?? rec;
     const url = asString2(attrs.src) || asString2(attrs.href) || asString2(attrs.url) || asString2(attrs.fileUrl) || asString2(attrs.downloadUrl);
     if (url && !seen.has(url)) {
       seen.add(url);
@@ -21152,7 +21847,7 @@ function filesFromAbleTimeDoc(value) {
 function listedAbleTimeFiles(raw) {
   const out = [];
   for (const item of asList2(raw)) {
-    const rec = asRecord9(item);
+    const rec = asRecord10(item);
     if (!rec) continue;
     const url = firstString(rec, ["url", "href", "src", "fileUrl", "downloadUrl", "permalink"]);
     if (!url) continue;
@@ -21172,7 +21867,7 @@ function mapAbleTimeAttachments(record) {
     ...filesFromAbleTimeDoc(record.description),
     ...filesFromAbleTimeDoc(record.content),
     ...asList2(record.comments).flatMap((item) => {
-      const rec = asRecord9(item);
+      const rec = asRecord10(item);
       return rec ? filesFromAbleTimeDoc(rec.content ?? rec.body) : [];
     })
   ].map((file) => ({
@@ -21214,7 +21909,7 @@ async function resolveAbleTimeAttachmentUrl(id, opts) {
     const json = await res.json().catch(() => null);
     const rec = json && typeof json === "object" && !Array.isArray(json) ? json.data && typeof json.data === "object" ? json.data : json : null;
     if (!rec) continue;
-    const url = firstString(rec, ["url", "href", "src", "fileUrl", "downloadUrl"]) || firstString(asRecord9(rec.file), ["url", "href"]);
+    const url = firstString(rec, ["url", "href", "src", "fileUrl", "downloadUrl"]) || firstString(asRecord10(rec.file), ["url", "href"]);
     if (url) {
       return {
         url,
@@ -21256,7 +21951,7 @@ var init_abletime_attachments = __esm({
 });
 
 // src/integrations/abletime-projects.ts
-function asRecord10(value) {
+function asRecord11(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function firstString2(record, keys) {
@@ -21269,7 +21964,7 @@ function firstString2(record, keys) {
 }
 function asList3(value) {
   if (Array.isArray(value)) return value;
-  const record = asRecord10(value);
+  const record = asRecord11(value);
   if (!record) return [];
   for (const key of ["data", "tasks", "projects", "items", "results", "nodes"]) {
     if (Array.isArray(record[key])) return record[key];
@@ -21277,7 +21972,7 @@ function asList3(value) {
   return [];
 }
 function ableTimeProjectFields(nested) {
-  const projectRecord = asRecord10(nested.project);
+  const projectRecord = asRecord11(nested.project);
   const projectId = firstString2(nested, ["project_id", "projectId"]) || firstString2(projectRecord, ["id"]) || void 0;
   const projectName = firstString2(nested, ["project_name", "projectName"]) || firstString2(projectRecord, ["name", "title"]) || void 0;
   if (!projectId && !projectName) return {};
@@ -21290,13 +21985,13 @@ function ableTimeProjectFields(nested) {
   };
 }
 function mapAbleTimeProject(raw) {
-  const record = asRecord10(raw);
+  const record = asRecord11(raw);
   if (!record) return null;
   const id = firstString2(record, ["id", "project_id", "projectId"]);
   const name = firstString2(record, ["name", "title", "projectName"]);
   if (!id && !name) return null;
   const categories = asList3(record.categories ?? record.category).map((item) => {
-    const rec = asRecord10(item);
+    const rec = asRecord11(item);
     if (!rec) return null;
     const categoryId = firstString2(rec, ["id", "category_id", "projectCategoryId", "categoryId"]);
     const categoryName = firstString2(rec, ["name", "title", "categoryName"]);
@@ -21332,7 +22027,7 @@ __export(abletime_exports, {
   updateAbleTimeTask: () => updateAbleTimeTask,
   verifyAbleTimeConnection: () => verifyAbleTimeConnection
 });
-function asRecord11(value) {
+function asRecord12(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function asString3(value) {
@@ -21349,14 +22044,14 @@ function firstString3(record, keys) {
 function firstRecord(record, keys) {
   if (!record) return null;
   for (const key of keys) {
-    const value = asRecord11(record[key]);
+    const value = asRecord12(record[key]);
     if (value) return value;
   }
   return null;
 }
 function asList4(value) {
   if (Array.isArray(value)) return value;
-  const record = asRecord11(value);
+  const record = asRecord12(value);
   if (!record) return [];
   for (const key of ["data", "tasks", "projects", "items", "results", "nodes"]) {
     if (Array.isArray(record[key])) return record[key];
@@ -21368,18 +22063,18 @@ function labelsOf(record) {
   if (!Array.isArray(raw)) return [];
   return raw.map((item) => {
     if (typeof item === "string") return item.trim();
-    const rec = asRecord11(item);
+    const rec = asRecord12(item);
     return rec ? firstString3(rec, ["name", "title", "label"]) : "";
   }).filter(Boolean);
 }
 function commentsOf(record) {
   const out = [];
   for (const item of asList4(record.comments ?? record.notes ?? record.discussion)) {
-    const rec = asRecord11(item);
+    const rec = asRecord12(item);
     if (!rec) continue;
     const body = firstString3(rec, ["body", "text", "comment", "message", "contentSanitized"]) || textFromAbleTimeDoc(rec.content);
     if (!body) continue;
-    const user = firstString3(asRecord11(rec.user) ?? asRecord11(rec.author), ["name", "display_name", "username"]) || firstString3(rec, ["user_name", "author", "username"]);
+    const user = firstString3(asRecord12(rec.user) ?? asRecord12(rec.author), ["name", "display_name", "username"]) || firstString3(rec, ["user_name", "author", "username"]);
     const id = firstString3(rec, ["id", "comment_id", "commentId"]);
     const url = firstString3(rec, ["url", "permalink"]);
     const createdAt = firstString3(rec, ["created_at", "createdAt", "created"]);
@@ -21406,7 +22101,7 @@ function taskUrl(task, host) {
   return `${base}/tasks/${slug}`;
 }
 function mapAbleTimeTask(raw, host) {
-  const record = asRecord11(raw);
+  const record = asRecord12(raw);
   if (!record) return null;
   const nested = firstRecord(record, ["task", "data"]) ?? record;
   const id = firstString3(nested, ["id", "task_id", "taskId", "timeflowTaskId"]);
@@ -21424,7 +22119,7 @@ function mapAbleTimeTask(raw, host) {
     description: firstString3(nested, ["description", "body", "details", "descriptionSanitized"]) || textFromAbleTimeDoc(nested.description) || void 0,
     state: firstString3(nested, ["state", "board_state", "boardState", "status", "taskState"]) || void 0,
     ...ableTimeProjectFields(nested),
-    categoryId: firstString3(nested, ["category_id", "categoryId", "projectCategoryId"]) || firstString3(asRecord11(nested.category), ["id"]) || void 0,
+    categoryId: firstString3(nested, ["category_id", "categoryId", "projectCategoryId"]) || firstString3(asRecord12(nested.category), ["id"]) || void 0,
     assignee: assigneeOf(nested),
     labels: labelsOf(nested),
     comments: commentsOf(nested),
@@ -21474,7 +22169,7 @@ function isOpenTask(task) {
 }
 async function getAbleTimeOrientation(opts) {
   const raw = await callAbleTimeTool("orientation", {}, opts);
-  const record = asRecord11(raw);
+  const record = asRecord12(raw);
   const viewerRec = firstRecord(record, ["viewer", "principal", "user", "actor", "me", "person"]) ?? record;
   const viewer = {
     id: firstString3(viewerRec, ["id", "user_id"]) || void 0,
@@ -21553,7 +22248,7 @@ async function commentAbleTimeTask(input, opts) {
     { id, task_id: id, task: id, body, comment: body, text: body },
     opts
   );
-  const rec = asRecord11(raw);
+  const rec = asRecord12(raw);
   return {
     id: rec ? firstString3(rec, ["id", "comment_id"]) || void 0 : void 0,
     body: rec ? firstString3(rec, ["body", "text", "comment"]) || body : body
@@ -22691,7 +23386,7 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
     ...instructions
   ].join("\n");
   return {
-    id: (0, import_node_crypto14.randomUUID)(),
+    id: (0, import_node_crypto16.randomUUID)(),
     name: orch ? "Orchestration quota handoff.md" : "Quota handoff.md",
     kind: "transcript",
     content: body
@@ -22723,11 +23418,11 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText, opts) {
   }
   return updateThread(tab.id, patch);
 }
-var import_node_crypto14, QUOTA_CONTINUE_PROMPT, QUOTA_CONTINUE_ACCOUNT_PROMPT, QUOTA_RESUME_PROMPT;
+var import_node_crypto16, QUOTA_CONTINUE_PROMPT, QUOTA_CONTINUE_ACCOUNT_PROMPT, QUOTA_RESUME_PROMPT;
 var init_quota_failover = __esm({
   "src/orchestrator/quota-failover.ts"() {
     "use strict";
-    import_node_crypto14 = require("crypto");
+    import_node_crypto16 = require("crypto");
     init_session_quota();
     init_app_settings();
     init_managed_accounts();
@@ -24790,7 +25485,7 @@ function compiledModuleDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    const url = import_meta6.url;
+    const url = import_meta8.url;
     if (typeof url === "string" && url.length > 0) {
       return (0, import_node_path60.dirname)((0, import_node_url5.fileURLToPath)(url));
     }
@@ -24829,7 +25524,7 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.cjs";
 }
-var import_node_fs61, import_node_path60, import_node_url5, import_meta6, DETACHED_JOB_FILENAMES;
+var import_node_fs61, import_node_path60, import_node_url5, import_meta8, DETACHED_JOB_FILENAMES;
 var init_detached_job_path = __esm({
   "src/skills/detached-job-path.ts"() {
     "use strict";
@@ -24837,7 +25532,7 @@ var init_detached_job_path = __esm({
     import_node_path60 = require("path");
     import_node_url5 = require("url");
     init_packaged_runtime();
-    import_meta6 = {};
+    import_meta8 = {};
     DETACHED_JOB_FILENAMES = ["detached-job.cjs", "detached-job.js"];
   }
 });
@@ -26205,7 +26900,7 @@ function buildTask(input, now) {
   const ts = nowIso2(now);
   const agent = input.agent ? coerceOrchestratorAgent(input.agent) : null;
   return {
-    id: (0, import_node_crypto15.randomUUID)(),
+    id: (0, import_node_crypto17.randomUUID)(),
     name: input.name?.trim() || defaultScheduleName(prompt),
     prompt,
     enabled: input.enabled !== false,
@@ -26305,11 +27000,11 @@ function recordScheduleRun(id, result) {
   writeAll2(rows);
   return next;
 }
-var import_node_crypto15, import_node_fs65, import_node_path64, import_croner, DURATION_RE, UNIT_MS;
+var import_node_crypto17, import_node_fs65, import_node_path64, import_croner, DURATION_RE, UNIT_MS;
 var init_schedules = __esm({
   "src/store/schedules.ts"() {
     "use strict";
-    import_node_crypto15 = require("crypto");
+    import_node_crypto17 = require("crypto");
     import_node_fs65 = require("fs");
     import_node_path64 = require("path");
     import_croner = require("croner");
@@ -26552,10 +27247,10 @@ function collectActiveRunPorts(runs) {
   return [...ports];
 }
 function getOrchestrator() {
-  if (!singleton) {
-    singleton = new Orchestrator();
+  if (!singleton2) {
+    singleton2 = new Orchestrator();
   }
-  return singleton;
+  return singleton2;
 }
 async function startOrchestration(opts) {
   const repoPath = opts.repoPath?.trim();
@@ -26615,7 +27310,7 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_crypto16, import_node_fs67, LIVE_TURN_SPAWN_GRACE_MS, RUN_SCRIPT_DESKTOP_ADOPT_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton;
+var import_node_events, import_node_crypto18, import_node_fs67, LIVE_TURN_SPAWN_GRACE_MS, RUN_SCRIPT_DESKTOP_ADOPT_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton2;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
@@ -26623,7 +27318,7 @@ var init_orchestrator = __esm({
     init_injected_notices();
     init_task_state();
     init_wait_for_turn();
-    import_node_crypto16 = require("crypto");
+    import_node_crypto18 = require("crypto");
     import_node_fs67 = require("fs");
     init_error_detail();
     init_run();
@@ -26649,6 +27344,7 @@ var init_orchestrator = __esm({
     init_usage();
     init_thread_store();
     init_desktop_host();
+    init_model_context();
     init_agent_block();
     init_child_halt();
     init_stop_reason();
@@ -27647,6 +28343,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
             orchestrationReminder,
             prGateDirective,
             injectedNoticeContext,
+            takeMcpAppModelContext(threadId),
             expandedPrompt
           ].filter(Boolean).join("\n\n");
           if (!autoContinue && sentAttachments) {
@@ -28275,7 +28972,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
         const request = sameIntent ? pending : {
           op,
           scriptName: scriptName ?? null,
-          requestId: (0, import_node_crypto16.randomUUID)(),
+          requestId: (0, import_node_crypto18.randomUUID)(),
           requestedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         if (!sameIntent) {
@@ -29396,7 +30093,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
         return thread;
       }
     };
-    singleton = null;
+    singleton2 = null;
   }
 });
 
@@ -29405,7 +30102,7 @@ init_nested_electron_env();
 init_system_ca();
 
 // src/mcp/server.ts
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_stdio2 = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/mcp/wrap-mcp-tools.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
@@ -29516,7 +30213,7 @@ function createClippedMcpServer() {
 
 // src/mcp/server.ts
 var import_zod11 = require("zod");
-var import_node_crypto20 = require("crypto");
+var import_node_crypto22 = require("crypto");
 var import_node_path68 = require("path");
 init_orchestrator();
 init_task_state();
@@ -30028,8 +30725,8 @@ init_fetch();
 init_issue_attachments();
 
 // src/integrations/linear-oauth.ts
-var import_node_crypto17 = require("crypto");
-var import_node_http2 = require("http");
+var import_node_crypto19 = require("crypto");
+var import_node_http3 = require("http");
 init_app_settings();
 init_fetch();
 
@@ -33014,7 +33711,7 @@ function registerScheduleTools(server) {
 }
 
 // src/agent-rpc/handlers.ts
-var import_node_crypto18 = require("crypto");
+var import_node_crypto20 = require("crypto");
 var import_node_path65 = require("path");
 init_wait_for_job();
 init_wait_for_turn();
@@ -33061,7 +33758,7 @@ setToolPermissionPublisher({
 // src/agent-rpc/handlers.ts
 init_protocol2();
 function presentArtifactResult(input) {
-  const id = input.artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${(0, import_node_crypto18.randomUUID)().slice(0, 8)}`;
+  const id = input.artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${(0, import_node_crypto20.randomUUID)().slice(0, 8)}`;
   return {
     ok: true,
     artifact_id: id,
@@ -33086,7 +33783,7 @@ init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
-var import_node_crypto19 = require("crypto");
+var import_node_crypto21 = require("crypto");
 var import_node_fs68 = require("fs");
 var import_node_path66 = require("path");
 init_paths();
@@ -34036,7 +34733,7 @@ async function startMcpServer() {
           const ident = issue?.identifier ?? ref.trim();
           const attachments = issue ? [
             {
-              id: (0, import_node_crypto20.randomUUID)(),
+              id: (0, import_node_crypto22.randomUUID)(),
               name: issue.identifier,
               kind: "issue",
               content: [
@@ -34589,7 +35286,7 @@ async function startMcpServer() {
       }
     );
   }
-  const transport = new import_stdio.StdioServerTransport();
+  const transport = new import_stdio2.StdioServerTransport();
   await server.connect(transport);
 }