@sideboard-ai/core 0.1.45 → 0.1.49

package/dist/chunk-RQI4TOXK.js

@@ -0,0 +1,2232 @@
+#!/usr/bin/env node
+
+import {
+  applyConnectedTeamToCli,
+  brightsyMcpServerName,
+  ensureCliTeamTracked,
+  ensureConnectedBrightsyTeamTokens,
+  loadBrightsyConfig
+} from "./chunk-E35APBHV.js";
+import {
+  claudeChromeEnabled,
+  loadAppSettings,
+  resolveClaudeExecutable
+} from "./chunk-HBJSHRY2.js";
+import {
+  ensureAgentPath,
+  run
+} from "./chunk-ISY4EGF6.js";
+
+// src/agents/brightsy-targets.ts
+function encodeBrightsyTarget(type, id, accountId) {
+  if (accountId) return `team:${accountId}:${type}:${id}`;
+  return `${type}:${id}`;
+}
+function decodeBrightsyTarget(model) {
+  const raw = model?.trim();
+  if (!raw || raw === "default" || raw === "agent:default") {
+    return { type: "agent", id: "default" };
+  }
+  const teamMatch = raw.match(/^team:([^:]+):(agent|model):(.+)$/);
+  if (teamMatch) {
+    return {
+      type: teamMatch[2],
+      id: teamMatch[3] || "default",
+      accountId: teamMatch[1]
+    };
+  }
+  if (raw.startsWith("agent:")) {
+    return { type: "agent", id: raw.slice("agent:".length) || "default" };
+  }
+  if (raw.startsWith("model:")) {
+    return { type: "model", id: raw.slice("model:".length) };
+  }
+  if (/^[0-9a-f]{8}-[0-9a-f-]{27,}$/i.test(raw) || raw === "default") {
+    return { type: "agent", id: raw };
+  }
+  return { type: "model", id: raw };
+}
+
+// src/agents/error-detail.ts
+function formatUnknownDetail(err) {
+  if (err == null) return "";
+  if (typeof err === "string") return err.trim();
+  if (err instanceof Error) {
+    const base = err.message.trim() || err.name;
+    const code = "code" in err && typeof err.code === "string" ? err.code.trim() : "";
+    return code && !base.includes(code) ? `${base} (${code})` : base;
+  }
+  if (typeof err === "object") {
+    const o = err;
+    const nested = o.error != null && typeof o.error === "object" ? formatUnknownDetail(o.error) : "";
+    const message = typeof o.message === "string" ? o.message.trim() : typeof o.error === "string" ? o.error.trim() : typeof o.result === "string" ? o.result.trim() : nested;
+    const code = typeof o.code === "string" ? o.code.trim() : "";
+    if (message) return code && !message.includes(code) ? `${message} (${code})` : message;
+    try {
+      const json = JSON.stringify(err);
+      if (json && json !== "{}" && json !== "null") return json;
+    } catch {
+    }
+  }
+  const fallback = String(err);
+  return fallback === "[object Object]" ? "" : fallback;
+}
+function extractJsonErrorMessage(obj) {
+  const nested = obj.error != null && typeof obj.error === "object" ? obj.error : null;
+  const candidates = [
+    typeof obj.message === "string" ? obj.message : null,
+    typeof obj.error === "string" ? obj.error : null,
+    nested && typeof nested.message === "string" ? nested.message : null,
+    typeof obj.result === "string" ? obj.result : null,
+    typeof obj.detail === "string" ? obj.detail : null
+  ];
+  for (const c of candidates) {
+    const t = c?.trim();
+    if (t) return t;
+  }
+  if (Array.isArray(obj.errors)) {
+    const parts = obj.errors.map((e) => formatUnknownDetail(e)).map((s) => s.trim()).filter(Boolean);
+    if (parts.length) return parts.join("; ");
+  }
+  return null;
+}
+var NODE_VERSION_FOOTER = /^Node\.js v\d+/i;
+function pushTurnStderr(tail, line, maxLines = 12) {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  if (NODE_VERSION_FOOTER.test(trimmed)) return;
+  if (/^reconnecting\.\.\./i.test(trimmed)) return;
+  tail.push(trimmed);
+  while (tail.length > maxLines) tail.shift();
+}
+function summarizeTurnStderr(tail, maxChars = 500) {
+  if (tail.length === 0) return "";
+  const moduleMissing = [...tail].reverse().find((line) => /cannot find module/i.test(line));
+  if (moduleMissing) {
+    return moduleMissing.length <= maxChars ? moduleMissing : moduleMissing.slice(0, maxChars);
+  }
+  const joined = tail.slice(-6).join("\n").trim();
+  if (joined.length <= maxChars) return joined;
+  return joined.slice(joined.length - maxChars);
+}
+function looksLikeAgentFailureMessage(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /you've hit your|hit your (session|weekly|opus) limit|usage limit/.test(lower) || /credit balance is too low|out of credits|insufficient.?quota|quota.?exceeded/.test(lower) || /invalid user api key|invalid api key|not logged in|not authenticated|unauthorized/.test(
+    lower
+  ) || /\b429\b|too many requests|rate.?limit/.test(lower) || /prompt is too long|context.*(too long|exceed)|conversation too long/.test(lower);
+}
+function fallbackTurnFailDetail(assistantText) {
+  const t = assistantText.trim();
+  if (!t) return "";
+  if (looksLikeAgentFailureMessage(t)) return t;
+  if (t.length <= 400 && !/\n\n/.test(t)) return t;
+  return "";
+}
+function humanizeAgentFailDetail(detail) {
+  const raw = detail.trim();
+  if (!raw) return raw;
+  const lower = raw.toLowerCase();
+  if (/credit balance is too low|out of credits|insufficient.?quota|quota.?exceeded|billing/.test(lower)) {
+    return `${raw} \u2014 add credits or switch auth, then retry.`;
+  }
+  if (/hit your (session|weekly|opus) limit|usage limit|you've hit your/.test(lower)) {
+    return raw.includes("reset") ? raw : `${raw} \u2014 wait for the limit window to reset, then retry.`;
+  }
+  if (/\b429\b|rate.?limit|too many requests/.test(lower)) {
+    return `${raw} \u2014 wait a moment and retry.`;
+  }
+  if (/invalid user api key|invalid api key|not logged in|not authenticated|unauthorized|authentication|please run.*login|codex login|claude auth|cursor api/.test(
+    lower
+  )) {
+    return `${raw} \u2014 check agent login / API key in Settings.`;
+  }
+  if (/model .{0,80}(not found|unavailable|unknown|invalid)/.test(lower)) {
+    return `${raw} \u2014 pick another model in the agent options.`;
+  }
+  if (/context.*(too long|exceed)|prompt is too long|conversation too long/.test(lower)) {
+    return `${raw} \u2014 start a new chat or compact context, then retry.`;
+  }
+  return raw;
+}
+function formatTurnExitError(exitCode, stderrSummary) {
+  const code = exitCode ?? 1;
+  const raw = stderrSummary.trim();
+  if (/^exit\s*\d+$/i.test(raw)) {
+    return `exit ${code}: agent exited without details (credits, auth, rate limits, or a CLI error)`;
+  }
+  const detail = humanizeAgentFailDetail(raw);
+  if (!detail) {
+    return `exit ${code}: agent exited without details (credits, auth, rate limits, or a CLI error)`;
+  }
+  if (looksLikeAgentFailureMessage(raw)) return detail;
+  return `exit ${code}: ${detail}`;
+}
+
+// src/agents/turn-input.ts
+function normalizeTurnInput(input) {
+  if (typeof input === "string") return { prompt: input };
+  return { prompt: input.prompt, cachedPrefix: input.cachedPrefix?.trim() || void 0 };
+}
+function flattenTurnInput(input) {
+  const { cachedPrefix, prompt } = normalizeTurnInput(input);
+  if (!cachedPrefix) return prompt;
+  return `${cachedPrefix}
+
+---
+
+Current request:
+${prompt}`;
+}
+
+// src/agents/brightsy.ts
+function usageFromBrightsy(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.prompt_tokens ?? 0);
+  const outputTokens = Number(usage.completion_tokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  const cached = Number(usage.prompt_tokens_details?.cached_tokens ?? 0);
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: cached || void 0
+  };
+}
+function parseBrightsyCliLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (obj.type === "text" && typeof obj.text === "string") {
+      return { type: "stdout", data: obj.text };
+    }
+    if (obj.type === "thinking" && typeof obj.text === "string") {
+      return { type: "thinking", data: obj.text };
+    }
+    if (obj.type === "error") {
+      const msg = extractJsonErrorMessage(obj) || formatUnknownDetail(obj.error) || formatUnknownDetail(obj.message) || trimmed;
+      return [
+        { type: "stderr", data: msg },
+        { type: "stdout", data: `Error: ${msg}` }
+      ];
+    }
+    if (obj.type === "usage") {
+      const usage = usageFromBrightsy(obj.usage);
+      return usage ? { type: "usage", data: usage } : null;
+    }
+    if (obj.type === "tool_use") {
+      const id = typeof obj.id === "string" && obj.id || `brightsy-tool-${Date.now()}`;
+      const name = typeof obj.name === "string" && obj.name || "brightsy_tool";
+      const input = obj.input && typeof obj.input === "object" && !Array.isArray(obj.input) ? obj.input : void 0;
+      return { type: "tool_use", id, name, input };
+    }
+    if (obj.type === "tool_result" || obj.type === "tool") {
+      const id = typeof obj.id === "string" && obj.id || typeof obj.tool_call_id === "string" && obj.tool_call_id || `brightsy-tool-${Date.now()}`;
+      const content = typeof obj.content === "string" ? obj.content : obj.content != null ? JSON.stringify(obj.content) : void 0;
+      return {
+        type: "tool_result",
+        id,
+        content,
+        isError: obj.isError === true
+      };
+    }
+    if (obj.type === "done") return null;
+    if (typeof obj.type === "string" && ["tool_use", "tool_result", "tool", "thinking", "usage", "error", "done", "text"].includes(
+      obj.type
+    )) {
+      return null;
+    }
+    return { type: "stdout", data: trimmed };
+  } catch {
+    if (trimmed.startsWith("{") && /"type"\s*:\s*"(tool_use|tool_result|tool|text|thinking|usage|done|error)"/.test(trimmed)) {
+      return null;
+    }
+    if (/error|failed|unauthorized|quota|limit|not logged in/i.test(trimmed)) {
+      return [
+        { type: "stderr", data: trimmed },
+        { type: "stdout", data: `Error: ${trimmed}` }
+      ];
+    }
+    return { type: "stdout", data: line };
+  }
+}
+async function fetchTeamChatTargets(team) {
+  const endpoint = (team.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  let agents = [
+    {
+      type: "agent",
+      id: "default",
+      name: "Default Agent",
+      description: "Account default agent (tools + memory)",
+      accountId: team.id,
+      accountSlug: team.slug,
+      accountName: team.name
+    }
+  ];
+  let models = [];
+  try {
+    const res = await fetch(`${endpoint}/api/v1beta/${team.id}/agents`, {
+      headers: { Authorization: `Bearer ${team.access_token}` }
+    });
+    if (res.ok) {
+      const json = await res.json();
+      const listed = (json.data || []).filter(
+        (a) => Boolean(a?.id && a?.name)
+      ).filter((a) => a.id !== "default").map((a) => ({
+        type: "agent",
+        id: a.id,
+        name: a.name,
+        description: a.description,
+        accountId: team.id,
+        accountSlug: team.slug,
+        accountName: team.name
+      }));
+      agents = [...agents, ...listed];
+      if (Array.isArray(json.models)) {
+        models = json.models.filter(
+          (m) => Boolean(m?.id && m?.name)
+        ).slice(0, 12).map((m) => ({
+          type: "model",
+          id: m.id,
+          name: m.name,
+          description: m.description,
+          accountId: team.id,
+          accountSlug: team.slug,
+          accountName: team.name
+        }));
+      }
+    }
+  } catch {
+  }
+  return {
+    accountId: team.id,
+    accountSlug: team.slug,
+    accountName: team.name,
+    agents,
+    models
+  };
+}
+async function listBrightsyChatTargetsViaCli() {
+  const listed = await run("brightsy", ["chat", "--list-targets", "--json"], {
+    reject: false
+  });
+  if (listed.exitCode !== 0 || !listed.stdout.trim()) {
+    throw new Error(
+      listed.stderr.trim() || "Failed to list Brightsy chat targets \u2014 is `brightsy` installed and logged in?"
+    );
+  }
+  try {
+    const parsed = JSON.parse(listed.stdout);
+    let accountId = null;
+    let accountSlug = "team";
+    let accountName = "Brightsy";
+    try {
+      const cfg = loadBrightsyConfig();
+      accountId = cfg.account_id;
+      accountSlug = cfg.account_slug || accountSlug;
+      accountName = cfg.account_slug || accountName;
+    } catch {
+    }
+    const agents = (Array.isArray(parsed.agents) ? parsed.agents : []).map((a) => ({
+      ...a,
+      accountId: accountId ?? void 0,
+      accountSlug,
+      accountName
+    }));
+    const models = (Array.isArray(parsed.models) ? parsed.models : []).map((m) => ({
+      ...m,
+      accountId: accountId ?? void 0,
+      accountSlug,
+      accountName
+    }));
+    const teams = accountId ? [
+      {
+        accountId,
+        accountSlug,
+        accountName,
+        agents,
+        models
+      }
+    ] : [];
+    return { teams, agents, models, activeAccountId: accountId };
+  } catch {
+    throw new Error("Brightsy --list-targets returned invalid JSON");
+  }
+}
+async function listBrightsyChatTargets() {
+  ensureCliTeamTracked();
+  const teamsRaw = await ensureConnectedBrightsyTeamTokens();
+  if (teamsRaw.length === 0) {
+    return listBrightsyChatTargetsViaCli();
+  }
+  let activeAccountId = null;
+  try {
+    activeAccountId = loadBrightsyConfig().account_id;
+  } catch {
+    activeAccountId = teamsRaw[0]?.id ?? null;
+  }
+  const teams = await Promise.all(teamsRaw.map((t) => fetchTeamChatTargets(t)));
+  teams.sort((a, b) => {
+    if (a.accountId === activeAccountId) return -1;
+    if (b.accountId === activeAccountId) return 1;
+    return a.accountSlug.localeCompare(b.accountSlug);
+  });
+  const active = teams.find((t) => t.accountId === activeAccountId) ?? teams[0] ?? null;
+  return {
+    teams,
+    agents: active?.agents ?? [],
+    models: active?.models ?? [],
+    activeAccountId
+  };
+}
+async function syncCliForTarget(accountId) {
+  if (!accountId) return;
+  const teams = await ensureConnectedBrightsyTeamTokens();
+  const team = teams.find((t) => t.id === accountId);
+  if (!team) return;
+  try {
+    const cfg = loadBrightsyConfig();
+    if (cfg.account_id === team.id && cfg.access_token === team.access_token) {
+      return;
+    }
+  } catch {
+  }
+  applyConnectedTeamToCli(team);
+}
+var brightsyAdapter = {
+  kind: "brightsy",
+  async detect() {
+    const which = await run("which", ["brightsy"], { reject: false });
+    if (which.exitCode !== 0) {
+      return {
+        agent: "brightsy",
+        installed: false,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "brightsy CLI not found on PATH \u2014 npm i -g @brightsy/cli"
+      };
+    }
+    const who = await run("brightsy", ["whoami"], { reject: false });
+    const authenticated = who.exitCode === 0 && /logged in as/i.test(who.stdout);
+    return {
+      agent: "brightsy",
+      installed: true,
+      authenticated,
+      linearMcp: false,
+      warnings: [],
+      reason: authenticated ? void 0 : "not logged in \u2014 run `brightsy login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const target = decodeBrightsyTarget(thread.model);
+    await syncCliForTarget(target.accountId);
+    const mode = thread.planMode ? "plan" : target.type === "model" ? "ask" : "agent";
+    const args = [
+      "chat",
+      "--json",
+      "--mode",
+      mode,
+      target.type === "model" ? "--model" : "--agent",
+      target.id
+    ];
+    return {
+      file: "brightsy",
+      args,
+      cwd: thread.worktreePath,
+      // Piped stdin becomes the message body (avoids ARG_MAX for long seeds).
+      stdin: prompt
+    };
+  },
+  parseEvent(line) {
+    return parseBrightsyCliLine(line);
+  },
+  async resolveSessionId() {
+    return null;
+  },
+  async buildAttach(thread) {
+    const target = decodeBrightsyTarget(thread.model);
+    await syncCliForTarget(target.accountId);
+    const args = target.type === "model" ? ["chat", "--model", target.id] : ["chat", "--agent", target.id];
+    return { file: "brightsy", args, cwd: thread.worktreePath };
+  }
+};
+
+// src/agents/claude.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/agents/claude-mcp.ts
+function parseMcpList(text) {
+  const servers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (!line || /^Checking MCP/i.test(line)) continue;
+    const m = line.match(/^(.+?):\s+\S+/);
+    if (!m) continue;
+    const name = m[1].trim();
+    if (!name || seen.has(name)) continue;
+    const needsAuth = /Needs authentication/i.test(line);
+    const connected = !needsAuth && /Connected/i.test(line);
+    if (!needsAuth && !connected) continue;
+    seen.add(name);
+    servers.push({ name, connected, needsAuth });
+  }
+  return servers;
+}
+function sanitizeMcpServerName(name) {
+  return name.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+function mcpAllowTools(servers) {
+  const out = [];
+  for (const s of servers) {
+    if (!s.connected) continue;
+    const id = sanitizeMcpServerName(s.name);
+    if (!id) continue;
+    out.push(`mcp__${id}`);
+    out.push(`mcp__${id}__*`);
+  }
+  return out;
+}
+function mcpAuthWarnings(servers) {
+  const needing = servers.filter((s) => s.needsAuth).map((s) => s.name);
+  if (needing.length === 0) return [];
+  return [
+    `MCP needs login: ${needing.join(", ")}. Run: claude mcp login "<name>"`
+  ];
+}
+
+// src/agents/injected-mcp.ts
+import { existsSync, mkdtempSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/agents/node-launch.ts
+function isAsarPath(filePath) {
+  return /\.asar([/\\]|$)/.test(filePath);
+}
+async function resolveNodeLaunch(scriptPath) {
+  if (isAsarPath(scriptPath)) {
+    return {
+      file: process.execPath,
+      env: { ELECTRON_RUN_AS_NODE: "1" }
+    };
+  }
+  const whichNode = await run("which", ["node"], { reject: false });
+  const nodeBin = whichNode.exitCode === 0 && whichNode.stdout.trim() ? whichNode.stdout.trim() : null;
+  if (nodeBin) {
+    return { file: nodeBin, env: {} };
+  }
+  return {
+    file: process.execPath,
+    env: { ELECTRON_RUN_AS_NODE: "1" }
+  };
+}
+
+// src/agents/injected-mcp.ts
+var SIDEBOARD_MCP_ALLOWED_TOOLS = [
+  "mcp__sideboard",
+  "mcp__sideboard__*"
+];
+var SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS = [
+  "mcp__sideboard__present_artifact",
+  "mcp__sideboard__present_schema",
+  "mcp__sideboard__present_files"
+];
+var brightsyMcpCommandCache = null;
+async function resolveBrightsyMcpCommand() {
+  const now = Date.now();
+  if (brightsyMcpCommandCache && now - brightsyMcpCommandCache.at < 6e4 && brightsyMcpCommandCache.command) {
+    return brightsyMcpCommandCache.command;
+  }
+  const which = await run("which", ["brightsy-mcp"], { reject: false });
+  const command = which.exitCode === 0 && which.stdout.trim() ? "brightsy-mcp" : "npx";
+  brightsyMcpCommandCache = { at: now, command };
+  return command;
+}
+function isBrightsyConnected() {
+  try {
+    loadBrightsyConfig();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mcpLaunch(cmd, name, env) {
+  if (cmd === "brightsy-mcp") {
+    return { name, command: "brightsy-mcp", ...env ? { env } : {} };
+  }
+  return {
+    name,
+    command: "npx",
+    args: ["-y", "@brightsy/mcp-server"],
+    ...env ? { env } : {}
+  };
+}
+function teamEnv(team) {
+  const endpoint = (team.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  return {
+    BRIGHTSY_API_TOKEN: team.access_token,
+    BRIGHTSY_ACCOUNT_ID: team.id,
+    BRIGHTSY_API_URL: endpoint
+  };
+}
+function brightsyMcpAllowedTools(serverNames) {
+  const out = [];
+  for (const name of serverNames) {
+    out.push(`mcp__${name}`, `mcp__${name}__*`);
+  }
+  return out;
+}
+function corePackageDir() {
+  const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
+  if (cjsDir) return cjsDir;
+  try {
+    const url = import.meta.url;
+    if (typeof url === "string" && url.length > 0) {
+      return dirname(fileURLToPath(url));
+    }
+  } catch {
+  }
+  try {
+    const req = createRequire(join(process.cwd(), "package.json"));
+    return dirname(req.resolve("@sideboard-ai/core"));
+  } catch {
+    return process.cwd();
+  }
+}
+function findSideboardMcpJsEntry() {
+  const override = process.env.SIDEBOARD_MCP_ENTRY?.trim() || process.env.SIDEBOARD_CLI?.trim();
+  if (override && existsSync(override)) return override;
+  let dir = corePackageDir();
+  for (let i = 0; i < 10; i++) {
+    const candidates = [
+      join(dir, "mcp/run-stdio.js"),
+      join(dir, "mcp/run-stdio.cjs"),
+      join(dir, "dist/mcp/run-stdio.js"),
+      join(dir, "dist/mcp/run-stdio.cjs"),
+      join(dir, "packages/core/dist/mcp/run-stdio.js"),
+      join(dir, "packages/cli/dist/index.js"),
+      join(dir, "cli/dist/index.js")
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) return p;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function resolveSideboardMcpServer() {
+  const entry = findSideboardMcpJsEntry();
+  if (entry) {
+    const isCli = /[/\\]cli[/\\]dist[/\\]index\.js$/.test(entry);
+    const scriptArgs = isCli ? [entry, "mcp"] : [entry];
+    const launch = await resolveNodeLaunch(entry);
+    return {
+      name: "sideboard",
+      command: launch.file,
+      args: scriptArgs,
+      ...Object.keys(launch.env).length > 0 ? { env: launch.env } : {}
+    };
+  }
+  const which = await run("which", ["sideboard"], { reject: false });
+  if (which.exitCode === 0 && which.stdout.trim()) {
+    return { name: "sideboard", command: which.stdout.trim(), args: ["mcp"] };
+  }
+  return { name: "sideboard", command: "sideboard", args: ["mcp"] };
+}
+async function buildInjectedMcpServers(opts) {
+  const servers = [];
+  if (opts.includeSideboard) {
+    servers.push(await resolveSideboardMcpServer());
+  }
+  if (opts.includeBrightsy && isBrightsyConnected()) {
+    const cmd = await resolveBrightsyMcpCommand();
+    const teams = await ensureConnectedBrightsyTeamTokens();
+    if (teams.length > 0) {
+      const used = /* @__PURE__ */ new Set();
+      for (const team of teams) {
+        let name = brightsyMcpServerName(team.slug);
+        if (used.has(name)) name = `${name}_${team.id.slice(0, 8)}`;
+        used.add(name);
+        servers.push(mcpLaunch(cmd, name, teamEnv(team)));
+      }
+    } else {
+      servers.push(mcpLaunch(cmd, "brightsy"));
+    }
+  }
+  return servers;
+}
+function toCursorMcpServers(servers) {
+  const out = {};
+  for (const s of servers) {
+    out[s.name] = {
+      command: s.command,
+      ...s.args ? { args: s.args } : {},
+      ...s.env ? { env: s.env } : {}
+    };
+  }
+  return out;
+}
+function toCodexMcpConfigArgs(servers) {
+  const args = [];
+  for (const s of servers) {
+    const prefix = `mcp_servers.${s.name}`;
+    args.push("-c", `${prefix}.command=${JSON.stringify(s.command)}`);
+    if (s.args?.length) {
+      args.push("-c", `${prefix}.args=${JSON.stringify(s.args)}`);
+    }
+    if (s.env) {
+      for (const [key, value] of Object.entries(s.env)) {
+        args.push("-c", `${prefix}.env.${key}=${JSON.stringify(value)}`);
+      }
+    }
+  }
+  return args;
+}
+function toOpencodeMcpConfigContent(servers) {
+  const mcp = {};
+  for (const s of servers) {
+    mcp[s.name] = {
+      type: "local",
+      command: [s.command, ...s.args ?? []],
+      enabled: true,
+      ...s.env && Object.keys(s.env).length > 0 ? { environment: s.env } : {}
+    };
+  }
+  return JSON.stringify({ mcp });
+}
+function writeMcpServersConfig(servers) {
+  if (servers.length === 0) return null;
+  const mcpServers = {};
+  for (const s of servers) {
+    mcpServers[s.name] = {
+      command: s.command,
+      ...s.args ? { args: s.args } : {},
+      ...s.env ? { env: s.env } : {}
+    };
+  }
+  const dir = mkdtempSync(join(tmpdir(), "sideboard-mcp-"));
+  const cfgPath = join(dir, "mcp.json");
+  writeFileSync(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  return cfgPath;
+}
+
+// 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 explicitly asks you to implement). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any files. Do not exit plan mode on your own.";
+function permissionMode(thread) {
+  if (thread.planMode) {
+    return {
+      claude: "plan",
+      opencodePermission: JSON.stringify({
+        edit: "deny",
+        write: "deny",
+        bash: { "*": "deny" }
+      }),
+      codexSandbox: "read-only"
+    };
+  }
+  if (thread.autonomy === "full") {
+    return {
+      claude: "bypassPermissions",
+      opencodePermission: JSON.stringify({ "*": "allow" }),
+      codexSandbox: "workspace-write"
+    };
+  }
+  return {
+    claude: "acceptEdits",
+    opencodePermission: JSON.stringify({
+      edit: "allow",
+      bash: { "*": "allow", "rm -rf *": "deny" }
+    }),
+    codexSandbox: "workspace-write"
+  };
+}
+
+// src/agents/claude.ts
+var BASE_ALLOWED_TOOLS = [
+  "Edit",
+  "Write",
+  "Bash",
+  "Read",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "WebSearch"
+];
+var CLAUDE_CHROME_ALLOWED_TOOLS = [
+  "mcp__claude-in-chrome",
+  "mcp__claude-in-chrome__*",
+  "Skill(claude-in-chrome)"
+];
+var CLAUDE_PROMPT_ARG_MAX = 2e5;
+async function loadMcpServers() {
+  const claude = resolveClaudeExecutable();
+  const mcpText = await run(claude, ["mcp", "list"], { reject: false });
+  return parseMcpList(`${mcpText.stdout}
+${mcpText.stderr}`);
+}
+function usageFromClaude(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.input_tokens ?? 0);
+  const outputTokens = Number(usage.output_tokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usage.cache_read_input_tokens ? Number(usage.cache_read_input_tokens) : void 0,
+    cacheWriteTokens: usage.cache_creation_input_tokens ? Number(usage.cache_creation_input_tokens) : void 0
+  };
+}
+function claudeResultErrorDetail(obj) {
+  const isError = Boolean(obj.is_error) || typeof obj.subtype === "string" && /^error/i.test(obj.subtype);
+  const fromResult = typeof obj.result === "string" ? obj.result.trim() : "";
+  if (fromResult && (isError || looksLikeAgentFailureMessage(fromResult))) {
+    return fromResult;
+  }
+  if (!isError) return null;
+  const errors = obj.errors;
+  if (Array.isArray(errors)) {
+    const parts = errors.map((e) => {
+      if (typeof e === "string") return e.trim();
+      if (e && typeof e === "object" && typeof e.message === "string") {
+        return e.message.trim();
+      }
+      return "";
+    }).filter(Boolean);
+    if (parts.length) return parts.join("; ");
+  }
+  if (typeof obj.error === "string" && obj.error.trim()) return obj.error.trim();
+  if (typeof obj.subtype === "string" && obj.subtype) {
+    return obj.subtype.replace(/^error[_-]?/i, "").replace(/_/g, " ") || "Claude turn failed";
+  }
+  return "Claude turn failed";
+}
+function eventsFromContentBlocks(blocks) {
+  if (!blocks?.length) return [];
+  const out = [];
+  for (const block of blocks) {
+    if (!block?.type) continue;
+    if (block.type === "text" && block.text) {
+      out.push({ type: "stdout", data: block.text });
+      continue;
+    }
+    if ((block.type === "thinking" || block.type === "redacted_thinking") && block.thinking) {
+      out.push({ type: "thinking", data: block.thinking });
+      continue;
+    }
+    if (block.type === "tool_use" && block.id && block.name) {
+      out.push({
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.input
+      });
+      continue;
+    }
+    if (block.type === "tool_result" && block.tool_use_id) {
+      const content = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map(
+        (c) => typeof c === "string" ? c : c && typeof c === "object" && "text" in c ? String(c.text ?? "") : ""
+      ).join("") : block.content != null ? JSON.stringify(block.content) : void 0;
+      out.push({
+        type: "tool_result",
+        id: block.tool_use_id,
+        content,
+        isError: Boolean(block.is_error)
+      });
+    }
+  }
+  return out;
+}
+var claudeAdapter = {
+  kind: "claude",
+  async detect() {
+    const claude = resolveClaudeExecutable();
+    if (claude !== "claude") {
+      if (!existsSync2(claude)) {
+        return {
+          agent: "claude",
+          installed: false,
+          authenticated: false,
+          linearMcp: false,
+          warnings: [],
+          reason: `Claude Code executable not found: ${claude}`
+        };
+      }
+    } else {
+      const which = await run("which", ["claude"], { reject: false });
+      if (which.exitCode !== 0) {
+        return {
+          agent: "claude",
+          installed: false,
+          authenticated: false,
+          linearMcp: false,
+          warnings: [],
+          reason: "claude CLI not found on PATH"
+        };
+      }
+    }
+    const auth = await run(claude, ["auth", "status"], { reject: false });
+    const authenticated = auth.exitCode === 0;
+    const servers = await loadMcpServers();
+    const linearMcp = servers.some(
+      (s) => s.connected && /linear/i.test(s.name)
+    );
+    return {
+      agent: "claude",
+      installed: true,
+      authenticated,
+      linearMcp,
+      warnings: mcpAuthWarnings(servers),
+      reason: authenticated ? void 0 : "claude auth status failed \u2014 run `claude auth login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const claude = resolveClaudeExecutable();
+    const turn = normalizeTurnInput(input);
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const effective = sessionId ? { prompt: turn.prompt } : turn;
+    const promptText = flattenTurnInput(effective);
+    const useStdin = promptText.length > CLAUDE_PROMPT_ARG_MAX;
+    if (process.env.SIDEBOARD_DEBUG_CLAUDE_TURN === "1") {
+      console.error(
+        `[sideboard/claude] promptChars=${promptText.length} resumed=${Boolean(sessionId)} stdin=${useStdin}`
+      );
+    }
+    const mode = permissionMode(thread);
+    const { isOrchestratorThread } = await import("./global-workspace-OJF4ENH4.js");
+    const isOrchestrator = isOrchestratorThread(thread);
+    const injectedServers = await buildInjectedMcpServers({
+      includeSideboard: true,
+      includeBrightsy: isBrightsyConnected()
+    });
+    const injectedBrightsyNames = injectedServers.filter((s) => s.name === "brightsy" || s.name.startsWith("brightsy_")).map((s) => s.name);
+    const chromeOn = claudeChromeEnabled();
+    let allowedTools;
+    if (isOrchestrator) {
+      allowedTools = [
+        ...BASE_ALLOWED_TOOLS,
+        ...SIDEBOARD_MCP_ALLOWED_TOOLS,
+        ...brightsyMcpAllowedTools(injectedBrightsyNames)
+      ];
+    } else {
+      const servers = await loadMcpServers();
+      allowedTools = [
+        ...BASE_ALLOWED_TOOLS,
+        ...mcpAllowTools(servers),
+        ...SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS,
+        ...brightsyMcpAllowedTools(injectedBrightsyNames)
+      ];
+    }
+    if (chromeOn) {
+      allowedTools = [...allowedTools, ...CLAUDE_CHROME_ALLOWED_TOOLS];
+    }
+    const args = [
+      "-p",
+      ...useStdin ? [] : [promptText],
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--permission-mode",
+      mode.claude
+    ];
+    const mcpConfigPath = writeMcpServersConfig(injectedServers);
+    if (mcpConfigPath) {
+      args.push("--mcp-config", mcpConfigPath);
+    }
+    if (chromeOn) {
+      args.push("--chrome");
+    }
+    if (useStdin) {
+      args.push("--input-format", "text");
+    }
+    for (const tool of allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+    if (thread.model) {
+      args.push("--model", thread.model);
+    }
+    const effort = thread.effort ?? (thread.fast ? "low" : "high");
+    args.push("--effort", effort);
+    if (sessionId) {
+      args.push("--resume", sessionId);
+    }
+    return {
+      file: claude,
+      args,
+      cwd: thread.worktreePath,
+      stdin: useStdin ? `${promptText}
+` : void 0
+    };
+  },
+  parseEvent(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj.type === "system" && obj.subtype === "init") {
+        const sid = obj.session_id;
+        if (typeof sid === "string") return { type: "session_id", data: sid };
+        return null;
+      }
+      if (obj.type === "system" && typeof obj.session_id === "string") {
+        return { type: "session_id", data: obj.session_id };
+      }
+      if (obj.type === "assistant" || obj.type === "user") {
+        const content = obj.message?.content;
+        const events = eventsFromContentBlocks(content);
+        if (events.length === 0) return null;
+        return events.length === 1 ? events[0] : events;
+      }
+      if (obj.type === "stream_event") {
+        const event = obj.event;
+        if (!event) return null;
+        if (event.type === "content_block_start" && event.content_block) {
+          const block = event.content_block;
+          if (block.type === "tool_use" && block.id && block.name) {
+            return {
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input
+            };
+          }
+          if (block.type === "thinking" && block.thinking) {
+            return { type: "thinking", data: block.thinking };
+          }
+          return null;
+        }
+        if (event.type === "content_block_delta" && event.delta) {
+          if (event.delta.text) return { type: "stdout", data: event.delta.text };
+          if (event.delta.thinking) return { type: "thinking", data: event.delta.thinking };
+          return null;
+        }
+        return null;
+      }
+      if (obj.type === "content_block_delta") {
+        const delta = obj.delta;
+        if (delta?.text) return { type: "stdout", data: delta.text };
+        if (delta?.thinking) return { type: "thinking", data: delta.thinking };
+        return null;
+      }
+      if (obj.type === "result") {
+        const events = [];
+        const errorDetail = claudeResultErrorDetail(obj);
+        if (errorDetail) {
+          events.push({ type: "stderr", data: errorDetail });
+        } else {
+          const text = obj.result;
+          if (typeof text === "string" && text) events.push({ type: "stdout", data: text });
+        }
+        const usage = usageFromClaude(obj.usage);
+        if (usage) events.push({ type: "usage", data: usage });
+        if (events.length === 0) return null;
+        return events.length === 1 ? events[0] : events;
+      }
+      return null;
+    } catch {
+      return { type: "stdout", data: line };
+    }
+  },
+  async resolveSessionId(_worktreePath, cached) {
+    return cached;
+  },
+  async buildAttach(thread) {
+    const claude = resolveClaudeExecutable();
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const args = sessionId ? ["--resume", sessionId] : [];
+    if (claudeChromeEnabled()) {
+      args.push("--chrome");
+    }
+    return { file: claude, args, cwd: thread.worktreePath };
+  },
+  async listLinearIssues(_repoPath) {
+    const claude = resolveClaudeExecutable();
+    const prompt = "List my assigned Linear issues as JSON array only, no markdown. Each item: id, identifier, title, url, labels (string[]).";
+    const { stdout, exitCode } = await run(
+      claude,
+      [
+        "-p",
+        prompt,
+        "--output-format",
+        "json",
+        "--permission-mode",
+        "bypassPermissions",
+        "--allowedTools",
+        "mcp__linear__*"
+      ],
+      { reject: false }
+    );
+    if (exitCode !== 0) return [];
+    return parseIssuesJson(stdout);
+  }
+};
+function parseIssuesJson(raw) {
+  const text = raw.trim();
+  const candidates = [text];
+  const match = text.match(/\[[\s\S]*\]/);
+  if (match) candidates.push(match[0]);
+  for (const c of candidates) {
+    try {
+      const parsed = JSON.parse(c);
+      if (Array.isArray(parsed)) {
+        return parsed.map((item) => ({
+          id: String(item.id ?? item.identifier ?? ""),
+          identifier: String(item.identifier ?? item.id ?? ""),
+          title: String(item.title ?? ""),
+          url: String(item.url ?? ""),
+          labels: Array.isArray(item.labels) ? item.labels.map(String) : []
+        }));
+      }
+      if (parsed && typeof parsed === "object" && typeof parsed.result === "string") {
+        return parseIssuesJson(parsed.result);
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+
+// src/agents/codex.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var CODEX_PROMPT_ARG_MAX = 2e5;
+var FALLBACK_CODEX_MODELS = [
+  { id: "gpt-5.6-sol", displayName: "GPT-5.6 Sol" },
+  { id: "gpt-5.6-terra", displayName: "GPT-5.6 Terra" },
+  { id: "gpt-5.6-luna", displayName: "GPT-5.6 Luna" },
+  { id: "gpt-5.5", displayName: "GPT-5.5" },
+  { id: "gpt-5.2", displayName: "GPT-5.2" }
+];
+var cachedCodexModels = null;
+var CODEX_MODEL_CACHE_MS = 5 * 60 * 1e3;
+async function listCodexModels() {
+  const now = Date.now();
+  if (cachedCodexModels && now - cachedCodexModels.at < CODEX_MODEL_CACHE_MS) {
+    return cachedCodexModels.models;
+  }
+  const which = await run("which", ["codex"], { reject: false });
+  if (which.exitCode !== 0) return FALLBACK_CODEX_MODELS;
+  const listed = await run("codex", ["debug", "models"], { reject: false });
+  if (listed.exitCode !== 0 || !listed.stdout.trim()) {
+    return cachedCodexModels?.models ?? FALLBACK_CODEX_MODELS;
+  }
+  try {
+    const parsed = JSON.parse(listed.stdout);
+    const rows = Array.isArray(parsed.models) ? parsed.models : [];
+    const preferred = rows.filter((m) => (m.visibility ?? "list") === "list");
+    const source = preferred.length > 0 ? preferred : rows;
+    const models = source.map((m) => ({
+      id: (m.slug || "").trim(),
+      displayName: (m.display_name || m.slug || "").trim(),
+      description: m.description,
+      priority: typeof m.priority === "number" ? m.priority : 999
+    })).filter((m) => m.id).sort((a, b) => a.priority - b.priority).map(({ id, displayName, description }) => ({ id, displayName, description }));
+    if (models.length === 0) return FALLBACK_CODEX_MODELS;
+    cachedCodexModels = { at: now, models };
+    return models;
+  } catch {
+    return cachedCodexModels?.models ?? FALLBACK_CODEX_MODELS;
+  }
+}
+function usageFromCodex(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.input_tokens ?? 0);
+  const outputTokens = Number(usage.output_tokens ?? 0) + Number(usage.reasoning_output_tokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usage.cached_input_tokens ? Number(usage.cached_input_tokens) : void 0
+  };
+}
+function codexConfigHasNetworkAccess() {
+  const candidates = [
+    join2(homedir(), ".codex", "config.toml"),
+    join2(homedir(), ".config", "codex", "config.toml")
+  ];
+  for (const path of candidates) {
+    if (!existsSync3(path)) continue;
+    const text = readFileSync(path, "utf8");
+    if (/network_access\s*=\s*true/.test(text)) return true;
+  }
+  return false;
+}
+var codexAdapter = {
+  kind: "codex",
+  async detect() {
+    const which = await run("which", ["codex"], { reject: false });
+    if (which.exitCode !== 0) {
+      return {
+        agent: "codex",
+        installed: false,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "codex CLI not found on PATH"
+      };
+    }
+    const auth = await run("codex", ["login", "status"], { reject: false });
+    const authenticated = auth.exitCode === 0;
+    const mcp = await run("codex", ["mcp", "list", "--json"], { reject: false });
+    const linearMcp = /linear/i.test(mcp.stdout + mcp.stderr);
+    const warnings = [];
+    if (!codexConfigHasNetworkAccess()) {
+      warnings.push(
+        "Codex workspace-write blocks network by default \u2014 set [sandbox_workspace_write] network_access = true in ~/.codex/config.toml if agents need npm install etc."
+      );
+    }
+    return {
+      agent: "codex",
+      installed: true,
+      authenticated,
+      linearMcp,
+      warnings,
+      reason: authenticated ? void 0 : "codex login status failed \u2014 run `codex login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const useStdin = prompt.length > CODEX_PROMPT_ARG_MAX;
+    const promptArg = useStdin ? "-" : prompt;
+    if (process.env.SIDEBOARD_DEBUG_CODEX_TURN === "1") {
+      const { cachedPrefix } = normalizeTurnInput(input);
+      console.error(
+        `[sideboard/codex] promptChars=${prompt.length} resumed=${Boolean(sessionId)} stdin=${useStdin} hasPrefix=${Boolean(cachedPrefix)}`
+      );
+    }
+    const mode = permissionMode(thread);
+    const model = thread.model?.trim();
+    const injected = await buildInjectedMcpServers({
+      includeSideboard: true,
+      includeBrightsy: isBrightsyConnected()
+    });
+    const mcpOverrides = toCodexMcpConfigArgs(injected);
+    const args = [
+      "exec",
+      ...sessionId ? ["resume", sessionId] : [],
+      promptArg,
+      "--cd",
+      thread.worktreePath,
+      "--json",
+      "--sandbox",
+      mode.codexSandbox,
+      "--ask-for-approval",
+      "never",
+      ...model ? ["--model", model] : [],
+      ...mcpOverrides
+    ];
+    return {
+      file: "codex",
+      args,
+      cwd: thread.worktreePath,
+      stdin: useStdin ? `${prompt}
+` : void 0
+    };
+  },
+  parseEvent(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    try {
+      const obj = JSON.parse(trimmed);
+      const type = typeof obj.type === "string" ? obj.type : "";
+      if (type === "turn.failed" || type === "turn_failed") {
+        const detail = extractJsonErrorMessage(obj) || extractJsonErrorMessage(obj.error ?? {}) || "Codex turn failed";
+        return { type: "stderr", data: detail };
+      }
+      if (type === "error") {
+        const detail = extractJsonErrorMessage(obj) || trimmed;
+        if (/^reconnecting\.\.\./i.test(detail)) return null;
+        return { type: "stderr", data: detail };
+      }
+      if (typeof obj.item === "object" && obj.item !== null) {
+        const item = obj.item;
+        if (item.type === "error") {
+          const detail = item.message?.trim() || extractJsonErrorMessage(obj) || "Codex item error";
+          return { type: "stderr", data: detail };
+        }
+        if (item.type === "agent_message" && item.text) {
+          return { type: "stdout", data: item.text };
+        }
+        if (item.status === "failed") {
+          const detail = item.message?.trim() || extractJsonErrorMessage(item) || `Codex ${item.type ?? "item"} failed`;
+          return { type: "stderr", data: detail };
+        }
+      }
+      const sid = typeof obj.session_id === "string" && obj.session_id || typeof obj.thread_id === "string" && obj.thread_id || typeof obj.session?.id === "string" && obj.session.id;
+      if (sid && (type === "thread.started" || type === "session" || !type)) {
+        return { type: "session_id", data: sid };
+      }
+      if (sid && type.endsWith(".started")) {
+        return { type: "session_id", data: sid };
+      }
+      if (type === "turn.completed" || type === "turn_completed") {
+        const usage = usageFromCodex(obj.usage);
+        return usage ? { type: "usage", data: usage } : null;
+      }
+      if (typeof obj.content === "string" && obj.content.trim()) {
+        return { type: "stdout", data: obj.content };
+      }
+      return null;
+    } catch {
+      if (/error|failed|unauthorized|quota|limit/i.test(trimmed)) {
+        return { type: "stderr", data: trimmed };
+      }
+      return { type: "stdout", data: line };
+    }
+  },
+  async resolveSessionId(_worktreePath, cached) {
+    return cached;
+  },
+  async buildAttach(thread) {
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    if (sessionId) {
+      return {
+        file: "codex",
+        args: ["exec", "resume", sessionId, "--cd", thread.worktreePath],
+        cwd: thread.worktreePath
+      };
+    }
+    return {
+      file: "codex",
+      args: ["--cd", thread.worktreePath],
+      cwd: thread.worktreePath
+    };
+  },
+  async listLinearIssues(_repoPath) {
+    const prompt = "List my assigned Linear issues as JSON array only: id, identifier, title, url, labels.";
+    const { stdout, exitCode } = await run(
+      "codex",
+      [
+        "exec",
+        prompt,
+        "--json",
+        "--sandbox",
+        "read-only",
+        "--ask-for-approval",
+        "never"
+      ],
+      { reject: false }
+    );
+    if (exitCode !== 0) return [];
+    const match = stdout.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    try {
+      const parsed = JSON.parse(match[0]);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/agents/cursor.ts
+import { existsSync as existsSync4 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Cursor } from "@cursor/sdk";
+
+// src/agents/cursor-events.ts
+function usageFromCursor(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.inputTokens ?? 0);
+  const outputTokens = Number(usage.outputTokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usage.cacheReadTokens ? Number(usage.cacheReadTokens) : void 0,
+    cacheWriteTokens: usage.cacheWriteTokens ? Number(usage.cacheWriteTokens) : void 0
+  };
+}
+function cursorSdkMessageToEvents(msg) {
+  if (!msg?.type) return [];
+  if (msg.type === "system" && msg.agent_id) {
+    return [{ type: "session_id", data: msg.agent_id }];
+  }
+  if (msg.type === "thinking" && msg.text) {
+    return [{ type: "thinking", data: msg.text }];
+  }
+  if (msg.type === "assistant" && msg.message?.content?.length) {
+    const out = [];
+    for (const block of msg.message.content) {
+      if (block?.type === "text" && block.text) {
+        out.push({ type: "stdout", data: block.text });
+      } else if (block?.type === "tool_use" && block.id && block.name) {
+        out.push({
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input && typeof block.input === "object" ? block.input : void 0
+        });
+      }
+    }
+    return out;
+  }
+  if (msg.type === "tool_call" && msg.call_id && msg.name) {
+    if (msg.status === "running") {
+      return [
+        {
+          type: "tool_use",
+          id: msg.call_id,
+          name: msg.name,
+          input: msg.args && typeof msg.args === "object" ? msg.args : void 0
+        }
+      ];
+    }
+    if (msg.status === "completed" || msg.status === "error") {
+      const content = typeof msg.result === "string" ? msg.result : msg.result != null ? JSON.stringify(msg.result) : void 0;
+      return [
+        {
+          type: "tool_result",
+          id: msg.call_id,
+          content,
+          isError: msg.status === "error"
+        }
+      ];
+    }
+  }
+  if (msg.type === "usage") {
+    const usage = usageFromCursor(msg.usage);
+    if (usage) return [{ type: "usage", data: usage }];
+  }
+  if (msg.type === "status" && msg.status === "ERROR") {
+    const rawMessage = msg.message;
+    const detail = (typeof rawMessage === "string" ? rawMessage.trim() : "") || extractJsonErrorMessage(msg) || formatUnknownDetail(msg.error) || msg.text || "Cursor run entered ERROR status";
+    return [{ type: "stderr", data: detail }];
+  }
+  if (msg.type === "error") {
+    const detail = extractJsonErrorMessage(msg) || formatUnknownDetail(msg.error) || msg.text || "Cursor run error";
+    return [{ type: "stderr", data: detail }];
+  }
+  return [];
+}
+function parseCursorRunnerLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (Array.isArray(obj)) return obj;
+    if (obj && typeof obj === "object" && "events" in obj && Array.isArray(obj.events)) {
+      return obj.events;
+    }
+    if (obj && typeof obj === "object" && "type" in obj) {
+      return obj;
+    }
+    return null;
+  } catch {
+    return { type: "stdout", data: line };
+  }
+}
+
+// src/agents/cursor.ts
+var FALLBACK_CURSOR_MODELS = [
+  { id: "default", displayName: "Auto" },
+  { id: "composer-2.5", displayName: "Composer 2.5" },
+  { id: "composer-2", displayName: "Composer 2" }
+];
+var cachedModels = null;
+var MODEL_CACHE_MS = 5 * 60 * 1e3;
+function resolveCursorApiKey() {
+  const fromEnv = (process.env.CURSOR_API_KEY || "").trim();
+  if (fromEnv) return fromEnv;
+  return (loadAppSettings().environment.CURSOR_API_KEY || "").trim();
+}
+function isCursorAutoModel(model) {
+  const id = (model ?? "").trim().toLowerCase();
+  return !id || id === "default" || id === "auto";
+}
+function resolveCursorModelId(model) {
+  if (isCursorAutoModel(model)) return "default";
+  return model.trim();
+}
+async function listCursorModels() {
+  const now = Date.now();
+  if (cachedModels && now - cachedModels.at < MODEL_CACHE_MS) {
+    return cachedModels.models;
+  }
+  const apiKey = resolveCursorApiKey();
+  if (!apiKey) return FALLBACK_CURSOR_MODELS;
+  try {
+    const listed = await Cursor.models.list({ apiKey });
+    const models = listed.map((m) => ({
+      id: m.id,
+      displayName: m.displayName || m.id,
+      description: m.description
+    })).filter((m) => Boolean(m.id));
+    if (models.length === 0) return FALLBACK_CURSOR_MODELS;
+    cachedModels = { at: now, models };
+    return models;
+  } catch {
+    return cachedModels?.models ?? FALLBACK_CURSOR_MODELS;
+  }
+}
+function entryDir() {
+  const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
+  if (cjsDir) return cjsDir;
+  try {
+    return dirname2(fileURLToPath2(import.meta.url));
+  } catch {
+    try {
+      const req = createRequire2(process.cwd() + "/");
+      return dirname2(req.resolve("@sideboard-ai/core"));
+    } catch {
+      return process.cwd();
+    }
+  }
+}
+function cursorRunnerPath() {
+  const root = entryDir();
+  const candidates = [
+    join3(root, "agents", "cursor-runner.js"),
+    join3(root, "agents", "cursor-runner.cjs"),
+    // If somehow resolved from package root instead of dist/
+    join3(root, "dist", "agents", "cursor-runner.js"),
+    join3(root, "dist", "agents", "cursor-runner.cjs"),
+    // Source tree (dev): packages/core/src/agents/cursor-runner.ts
+    join3(root, "cursor-runner.ts"),
+    join3(root, "src", "agents", "cursor-runner.ts")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync4(candidate)) return candidate;
+  }
+  return candidates[0];
+}
+var cursorAdapter = {
+  kind: "cursor",
+  async detect() {
+    const apiKey = resolveCursorApiKey();
+    if (!apiKey) {
+      return {
+        agent: "cursor",
+        installed: true,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "CURSOR_API_KEY not set \u2014 add it in Settings \u2192 Agents \u2192 Cursor, or Settings \u2192 Environment"
+      };
+    }
+    try {
+      await Cursor.models.list({ apiKey });
+      return {
+        agent: "cursor",
+        installed: true,
+        authenticated: true,
+        linearMcp: false,
+        warnings: []
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        agent: "cursor",
+        installed: true,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: `Cursor API auth failed: ${message}`
+      };
+    }
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const agentId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const apiKey = resolveCursorApiKey() || void 0;
+    const injected = await buildInjectedMcpServers({
+      includeSideboard: true,
+      includeBrightsy: isBrightsyConnected()
+    });
+    const mcpServers = toCursorMcpServers(injected);
+    const req = {
+      prompt,
+      cwd: thread.worktreePath,
+      agentId,
+      model: thread.model,
+      effort: thread.effort,
+      fast: thread.fast,
+      planMode: thread.planMode,
+      apiKey,
+      ...Object.keys(mcpServers).length > 0 ? { mcpServers } : {}
+    };
+    const runner = cursorRunnerPath();
+    const isTs = runner.endsWith(".ts");
+    const launch = await resolveNodeLaunch(runner);
+    return {
+      file: launch.file,
+      args: isTs ? ["--import", "tsx", runner] : [runner],
+      cwd: thread.worktreePath,
+      stdin: JSON.stringify(req),
+      env: {
+        ...launch.env,
+        ...apiKey ? { CURSOR_API_KEY: apiKey } : {}
+      }
+    };
+  },
+  parseEvent(line) {
+    return parseCursorRunnerLine(line);
+  },
+  async resolveSessionId(_worktreePath, cached) {
+    return cached;
+  },
+  async buildAttach(thread) {
+    const which = await run("which", ["cursor"], { reject: false });
+    if (which.exitCode === 0) {
+      return { file: "cursor", args: [thread.worktreePath], cwd: thread.worktreePath };
+    }
+    throw new Error(
+      "Cursor agents have no interactive CLI attach. Install the Cursor shell command (`cursor`) to open the worktree, or continue the thread in Sideboard."
+    );
+  }
+};
+
+// src/agents/opencode.ts
+var FALLBACK_OPENCODE_MODELS = [
+  { id: "opencode/big-pickle", displayName: "opencode \xB7 big-pickle" },
+  {
+    id: "openrouter/~anthropic/claude-sonnet-latest",
+    displayName: "openrouter \xB7 claude-sonnet-latest"
+  },
+  {
+    id: "openrouter/~openai/gpt-latest",
+    displayName: "openrouter \xB7 gpt-latest"
+  }
+];
+var cachedOpencodeModels = null;
+var OPENCODE_MODEL_CACHE_MS = 5 * 60 * 1e3;
+function displayNameFromOpencodeId(id) {
+  const slash = id.indexOf("/");
+  if (slash <= 0) return id;
+  const provider = id.slice(0, slash);
+  const name = id.slice(slash + 1);
+  return `${provider} \xB7 ${name}`;
+}
+function sortOpencodeModelIds(ids) {
+  return [...ids].sort((a, b) => {
+    const aLatest = /latest|~/.test(a) ? 0 : 1;
+    const bLatest = /latest|~/.test(b) ? 0 : 1;
+    if (aLatest !== bLatest) return aLatest - bLatest;
+    const aOc = a.startsWith("opencode/") ? 0 : 1;
+    const bOc = b.startsWith("opencode/") ? 0 : 1;
+    if (aOc !== bOc) return aOc - bOc;
+    return a.localeCompare(b);
+  });
+}
+async function listOpencodeModels() {
+  const now = Date.now();
+  if (cachedOpencodeModels && now - cachedOpencodeModels.at < OPENCODE_MODEL_CACHE_MS) {
+    return cachedOpencodeModels.models;
+  }
+  const which = await run("which", ["opencode"], { reject: false });
+  if (which.exitCode !== 0) return FALLBACK_OPENCODE_MODELS;
+  const listed = await run("opencode", ["models"], { reject: false });
+  if (listed.exitCode !== 0 || !listed.stdout.trim()) {
+    return cachedOpencodeModels?.models ?? FALLBACK_OPENCODE_MODELS;
+  }
+  const ids = listed.stdout.split("\n").map((l) => l.trim()).filter((l) => /^[\w.~@+-]+\/[\w.~@+/-]+$/.test(l));
+  const unique = [...new Set(ids)];
+  if (unique.length === 0) return FALLBACK_OPENCODE_MODELS;
+  const OPENCODE_PICKER_LIMIT = 60;
+  const models = sortOpencodeModelIds(unique).slice(0, OPENCODE_PICKER_LIMIT).map((id) => ({
+    id,
+    displayName: displayNameFromOpencodeId(id)
+  }));
+  cachedOpencodeModels = { at: now, models };
+  return models;
+}
+function usageFromOpencode(tokens) {
+  if (!tokens) return null;
+  const inputTokens = Number(tokens.input ?? 0);
+  const outputTokens = Number(tokens.output ?? 0) + Number(tokens.reasoning ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: tokens.cache?.read ? Number(tokens.cache.read) : void 0,
+    cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
+  };
+}
+var opencodeAdapter = {
+  kind: "opencode",
+  async detect() {
+    const which = await run("which", ["opencode"], { reject: false });
+    if (which.exitCode !== 0) {
+      return {
+        agent: "opencode",
+        installed: false,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "opencode CLI not found on PATH"
+      };
+    }
+    const auth = await run("opencode", ["auth", "list"], { reject: false });
+    const authenticated = auth.exitCode === 0 && auth.stdout.trim().length > 0;
+    const mcp = await run("opencode", ["mcp", "list"], { reject: false });
+    const linearMcp = /linear/i.test(mcp.stdout + mcp.stderr);
+    return {
+      agent: "opencode",
+      installed: true,
+      authenticated,
+      linearMcp,
+      warnings: [],
+      reason: authenticated ? void 0 : "opencode auth list empty \u2014 run `opencode auth login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const mode = permissionMode(thread);
+    const model = thread.model?.trim();
+    const args = [
+      "run",
+      "--dir",
+      thread.worktreePath,
+      "--format",
+      "json"
+    ];
+    if (sessionId) {
+      args.push("--session", sessionId);
+    }
+    if (model) {
+      args.push("--model", model);
+    }
+    const injected = await buildInjectedMcpServers({
+      includeSideboard: true,
+      includeBrightsy: isBrightsyConnected()
+    });
+    const mcpContent = injected.length > 0 ? toOpencodeMcpConfigContent(injected) : null;
+    return {
+      file: "opencode",
+      args,
+      cwd: thread.worktreePath,
+      // `opencode run` treats non-TTY stdin as the message body when no positional
+      // message is given (see resolveRunInput in opencode's run.ts).
+      stdin: prompt,
+      env: {
+        OPENCODE_PERMISSION: mode.opencodePermission,
+        ...mcpContent ? { OPENCODE_CONFIG_CONTENT: mcpContent } : {}
+      }
+    };
+  },
+  parseEvent(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj.type === "error") {
+        const detail = extractJsonErrorMessage(obj) || formatUnknownDetail(obj.error) || formatUnknownDetail(obj.message) || trimmed;
+        return { type: "stderr", data: detail };
+      }
+      const sid = typeof obj.sessionID === "string" && obj.sessionID || typeof obj.sessionId === "string" && obj.sessionId || typeof obj.session_id === "string" && obj.session_id;
+      if (sid) return { type: "session_id", data: sid };
+      if (obj.type === "text") {
+        const text = obj.part?.text ?? obj.text;
+        if (text) return { type: "stdout", data: text };
+      }
+      if (obj.type === "tool_use") {
+        const part = obj.part;
+        const id = part?.id ?? obj.id ?? `tool-${Date.now()}`;
+        const name = part?.name ?? part?.tool ?? obj.name ?? obj.tool ?? "tool";
+        const input = part?.input ?? obj.input;
+        return { type: "tool_use", id, name, input };
+      }
+      if (obj.type === "tool_result") {
+        const part = obj.part;
+        const id = part?.tool_use_id ?? part?.id ?? obj.tool_use_id ?? obj.id;
+        if (!id) return null;
+        return {
+          type: "tool_result",
+          id,
+          content: part?.output ?? part?.content ?? obj.output ?? obj.content
+        };
+      }
+      if (obj.type === "step_finish" || obj.type === "step-finish") {
+        const part = obj.part;
+        const usage = usageFromOpencode(
+          part?.tokens ?? obj.tokens
+        );
+        return usage ? { type: "usage", data: usage } : null;
+      }
+      return null;
+    } catch {
+      if (/error|failed|unauthorized|quota|limit/i.test(trimmed)) {
+        return { type: "stderr", data: trimmed };
+      }
+      return { type: "stdout", data: line };
+    }
+  },
+  async resolveSessionId(worktreePath, cached) {
+    const listed = await run(
+      "opencode",
+      ["session", "list", "--format", "json"],
+      { cwd: worktreePath, reject: false }
+    );
+    if (listed.exitCode === 0 && listed.stdout.trim()) {
+      try {
+        const sessions = JSON.parse(listed.stdout);
+        if (Array.isArray(sessions) && sessions.length > 0) {
+          const norm = (p) => p.replace(/\/+$/, "");
+          const wt = norm(worktreePath);
+          const match = sessions.find(
+            (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
+          );
+          if (match?.id) return match.id;
+        }
+      } catch {
+      }
+    }
+    return cached;
+  },
+  async buildAttach(thread) {
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const args = ["--dir", thread.worktreePath];
+    if (sessionId) args.push("--session", sessionId);
+    return {
+      file: "opencode",
+      args,
+      cwd: thread.worktreePath,
+      env: {
+        OPENCODE_PERMISSION: permissionMode(thread).opencodePermission
+      }
+    };
+  },
+  async listLinearIssues(_repoPath) {
+    const prompt = "List my assigned Linear issues as JSON array only: id, identifier, title, url, labels.";
+    const { stdout, exitCode } = await run(
+      "opencode",
+      ["run", prompt, "--format", "json"],
+      {
+        reject: false,
+        env: { OPENCODE_PERMISSION: JSON.stringify({ "*": "allow" }) }
+      }
+    );
+    if (exitCode !== 0) return [];
+    const texts = [];
+    for (const line of stdout.split("\n")) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "text") {
+          texts.push(obj.part?.text ?? obj.text ?? "");
+        }
+      } catch {
+      }
+    }
+    const joined = texts.join("");
+    const match = joined.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    try {
+      return JSON.parse(match[0]);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/agents/list-models.ts
+var CLAUDE_MODEL_CATALOG = [
+  { id: "fable", displayName: "Fable" },
+  { id: "opus", displayName: "Opus" },
+  { id: "sonnet", displayName: "Sonnet" },
+  { id: "haiku", displayName: "Haiku" }
+];
+async function listBrightsyModels() {
+  try {
+    const targets = await listBrightsyChatTargets();
+    const accountId = targets.activeAccountId;
+    const models = (targets.models ?? []).map((m) => ({
+      id: encodeBrightsyTarget("model", m.id, accountId),
+      displayName: m.name || m.id,
+      description: m.description ?? void 0
+    }));
+    const agents = (targets.agents ?? []).map((a) => ({
+      id: encodeBrightsyTarget("agent", a.id, accountId),
+      displayName: a.name || a.id,
+      description: a.description ?? "Brightsy agent target"
+    }));
+    return [...models, ...agents].slice(0, 80);
+  } catch {
+    return [];
+  }
+}
+async function listModelsForAgent(agent) {
+  const kinds = agent ? [agent] : ["claude", "codex", "opencode", "cursor", "brightsy"];
+  const out = [];
+  for (const kind of kinds) {
+    if (kind === "claude") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: CLAUDE_MODEL_CATALOG,
+        note: "Default Auto \u2014 only pass a model id when you have a reason."
+      });
+      continue;
+    }
+    if (kind === "codex") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: await listCodexModels(),
+        note: "Default Auto \u2014 only pass a model slug when you have a reason."
+      });
+      continue;
+    }
+    if (kind === "opencode") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: await listOpencodeModels(),
+        note: "Default Auto \u2014 only pass a provider/model id when you have a reason."
+      });
+      continue;
+    }
+    if (kind === "cursor") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: await listCursorModels(),
+        note: 'Default Auto \u2014 only pass a model id when you have a reason (or use "default").'
+      });
+      continue;
+    }
+    if (kind === "brightsy") {
+      const models = await listBrightsyModels();
+      out.push({
+        agent: kind,
+        auto: true,
+        models,
+        note: models.length ? "Default Auto / Default agent \u2014 only pass a model/agent id when you have a reason." : "Brightsy not logged in or no targets \u2014 leave model unset for Default."
+      });
+    }
+  }
+  return out;
+}
+
+// src/agents/session-quota.ts
+function isSessionQuotaLimit(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  if (/credit balance is too low|out of credits|insufficient.?quota|billing/.test(lower)) {
+    return false;
+  }
+  if (/prompt is too long|context.*(too long|exceed)|conversation too long/.test(lower)) {
+    return false;
+  }
+  return /you've hit your/.test(lower) || /hit your (session|weekly|opus) limit/.test(lower) || /usage limit/.test(lower) || /rate.?limit|too many requests|\b429\b/.test(lower) && /reset/i.test(text);
+}
+function parseSessionQuotaResetAt(text, now = /* @__PURE__ */ new Date()) {
+  const absolute = text.match(
+    /resets\s+(?:at\s+)?(\d{1,2}):(\d{2})\s*(am|pm)(?:\s*\(([^)]+)\))?/i
+  );
+  if (absolute) {
+    const hour12 = Number(absolute[1]);
+    const minute = Number(absolute[2]);
+    const ampm = absolute[3].toLowerCase();
+    const timeZone = absolute[4]?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    let hour = hour12 % 12;
+    if (ampm === "pm") hour += 12;
+    const at = zonedWallTimeToUtc(now, hour, minute, timeZone);
+    if (!at) return null;
+    if (at.getTime() <= now.getTime() + 3e4) {
+      const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1e3);
+      return zonedWallTimeToUtc(tomorrow, hour, minute, timeZone);
+    }
+    return at;
+  }
+  const relative = text.match(
+    /resets\s+in\s+(\d+)\s*(minutes?|hours?|days?)/i
+  );
+  if (relative) {
+    const n = Number(relative[1]);
+    const unit = relative[2].toLowerCase();
+    const ms = unit.startsWith("day") ? n * 24 * 60 * 60 * 1e3 : unit.startsWith("hour") ? n * 60 * 60 * 1e3 : n * 60 * 1e3;
+    return new Date(now.getTime() + ms);
+  }
+  return null;
+}
+function zonedWallTimeToUtc(day, hour, minute, timeZone) {
+  try {
+    const cal = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    const parts = Object.fromEntries(
+      cal.formatToParts(day).filter((p) => p.type !== "literal").map((p) => [p.type, p.value])
+    );
+    const year = Number(parts.year);
+    const month = Number(parts.month);
+    const date = Number(parts.day);
+    if (![year, month, date].every((n) => Number.isFinite(n))) return null;
+    const utcGuess = Date.UTC(year, month - 1, date, hour, minute, 0);
+    const dtf = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+    const asParts = Object.fromEntries(
+      dtf.formatToParts(new Date(utcGuess)).filter((p) => p.type !== "literal").map((p) => [p.type, p.value])
+    );
+    const asUtc = Date.UTC(
+      Number(asParts.year),
+      Number(asParts.month) - 1,
+      Number(asParts.day),
+      Number(asParts.hour),
+      Number(asParts.minute),
+      Number(asParts.second || "0")
+    );
+    const offset = asUtc - utcGuess;
+    return new Date(utcGuess - offset);
+  } catch {
+    return null;
+  }
+}
+var FALLBACK_ORDER = [
+  "cursor",
+  "codex",
+  "opencode",
+  "claude"
+];
+function resolveQuotaFallbackAgent(current, preferred) {
+  const ordered = [
+    ...preferred && preferred !== "brightsy" ? [preferred] : [],
+    ...FALLBACK_ORDER.filter((a) => a !== preferred)
+  ];
+  return ordered.find((a) => a !== current) ?? (current === "cursor" ? "codex" : "cursor");
+}
+
+// src/agents/install.ts
+var SETUP = {
+  claude: {
+    agent: "claude",
+    kind: "cli",
+    summary: "Install the Claude Code CLI, then complete login in a terminal.",
+    docsUrl: "https://code.claude.com/docs/en/install",
+    installCommand: "npm install -g @anthropic-ai/claude-code",
+    loginCommand: "claude auth login",
+    npmPackage: "@anthropic-ai/claude-code"
+  },
+  codex: {
+    agent: "codex",
+    kind: "cli",
+    summary: "Install the Codex CLI, then run login in a terminal.",
+    docsUrl: "https://github.com/openai/codex",
+    installCommand: "npm install -g @openai/codex",
+    loginCommand: "codex login",
+    npmPackage: "@openai/codex"
+  },
+  opencode: {
+    agent: "opencode",
+    kind: "cli",
+    summary: "Install OpenCode (curl installer or npm), then authenticate providers.",
+    docsUrl: "https://opencode.ai/docs",
+    // Prefer the official installer; npm package name is opencode-ai.
+    installCommand: "curl -fsSL https://opencode.ai/install | bash",
+    loginCommand: "opencode auth login",
+    npmPackage: "opencode-ai@latest"
+  },
+  cursor: {
+    agent: "cursor",
+    kind: "bundled-sdk",
+    summary: "No CLI install \u2014 Sideboard ships the Cursor SDK. Add a CURSOR_API_KEY from the Cursor dashboard.",
+    docsUrl: "https://cursor.com/dashboard/integrations",
+    installCommand: null,
+    loginCommand: null
+  },
+  brightsy: {
+    agent: "brightsy",
+    kind: "cli",
+    summary: "Install the Brightsy CLI, then run `brightsy login`.",
+    docsUrl: "https://www.npmjs.com/package/@brightsy/cli",
+    installCommand: "npm install -g @brightsy/cli",
+    loginCommand: "brightsy login",
+    npmPackage: "@brightsy/cli"
+  }
+};
+function getAgentSetupInfo(agent) {
+  return SETUP[agent];
+}
+function listAgentSetupInfo() {
+  return Object.values(SETUP);
+}
+async function openInSystemTerminal(command) {
+  ensureAgentPath();
+  const trimmed = command.trim();
+  if (!trimmed) throw new Error("Command is empty");
+  if (process.platform === "darwin") {
+    const escaped = trimmed.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const script = `tell application "Terminal" to do script "${escaped}"`;
+    const result = await run("osascript", ["-e", script], { reject: false });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to open Terminal");
+    }
+    await run("osascript", ["-e", 'tell application "Terminal" to activate'], {
+      reject: false
+    });
+    return;
+  }
+  if (process.platform === "win32") {
+    const result = await run(
+      "cmd.exe",
+      ["/c", "start", "cmd.exe", "/k", trimmed],
+      { reject: false }
+    );
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to open cmd");
+    }
+    return;
+  }
+  const candidates = [
+    { file: "gnome-terminal", args: ["--", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "x-terminal-emulator", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "konsole", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "xterm", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] }
+  ];
+  for (const c of candidates) {
+    const which = await run("which", [c.file], { reject: false });
+    if (which.exitCode !== 0 || !which.stdout.trim()) continue;
+    const result = await run(c.file, c.args, { reject: false });
+    if (result.exitCode === 0) return;
+  }
+  throw new Error(
+    `No terminal found to run: ${trimmed}. Install gnome-terminal (or similar), or run the command manually.`
+  );
+}
+async function installAgent(agent) {
+  const info = getAgentSetupInfo(agent);
+  if (info.kind === "bundled-sdk" || info.kind === "api-key") {
+    return {
+      ok: true,
+      message: info.summary
+    };
+  }
+  if (!info.installCommand) {
+    return { ok: false, message: `No install command for ${agent}` };
+  }
+  if (/curl\s| \|\s*bash/.test(info.installCommand) || !info.npmPackage) {
+    await openInSystemTerminal(info.installCommand);
+    return {
+      ok: true,
+      openedTerminal: true,
+      command: info.installCommand,
+      message: `Opened Terminal to run: ${info.installCommand}`
+    };
+  }
+  ensureAgentPath();
+  const result = await run("npm", ["install", "-g", info.npmPackage], { reject: false });
+  const ok = result.exitCode === 0;
+  if (!ok) {
+    try {
+      await openInSystemTerminal(info.installCommand);
+      return {
+        ok: false,
+        openedTerminal: true,
+        command: info.installCommand,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        message: `npm install failed (exit ${result.exitCode}). Opened Terminal with: ${info.installCommand}`
+      };
+    } catch {
+      return {
+        ok: false,
+        command: info.installCommand,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        message: result.stderr.trim() || result.stdout.trim() || `npm install failed (exit ${result.exitCode})`
+      };
+    }
+  }
+  return {
+    ok: true,
+    command: info.installCommand,
+    exitCode: 0,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    message: `Installed ${info.npmPackage}`
+  };
+}
+async function loginAgent(agent) {
+  const info = getAgentSetupInfo(agent);
+  if (!info.loginCommand) {
+    return {
+      ok: true,
+      message: info.kind === "bundled-sdk" || info.kind === "api-key" ? info.summary : `No login command for ${agent}`
+    };
+  }
+  await openInSystemTerminal(info.loginCommand);
+  return {
+    ok: true,
+    openedTerminal: true,
+    command: info.loginCommand,
+    message: `Opened Terminal to run: ${info.loginCommand}`
+  };
+}
+
+// src/agents/index.ts
+var adapters = {
+  claude: claudeAdapter,
+  codex: codexAdapter,
+  opencode: opencodeAdapter,
+  brightsy: brightsyAdapter,
+  cursor: cursorAdapter
+};
+function getAdapter(kind) {
+  return adapters[kind];
+}
+function allAdapters() {
+  return Object.values(adapters);
+}
+
+export {
+  pushTurnStderr,
+  summarizeTurnStderr,
+  looksLikeAgentFailureMessage,
+  fallbackTurnFailDetail,
+  humanizeAgentFailDetail,
+  formatTurnExitError,
+  encodeBrightsyTarget,
+  decodeBrightsyTarget,
+  parseBrightsyCliLine,
+  listBrightsyChatTargets,
+  brightsyAdapter,
+  PLAN_MODE_INSTRUCTION,
+  permissionMode,
+  claudeAdapter,
+  listCodexModels,
+  codexAdapter,
+  cursorSdkMessageToEvents,
+  parseCursorRunnerLine,
+  isCursorAutoModel,
+  resolveCursorModelId,
+  listCursorModels,
+  cursorAdapter,
+  listOpencodeModels,
+  opencodeAdapter,
+  CLAUDE_MODEL_CATALOG,
+  listModelsForAgent,
+  isSessionQuotaLimit,
+  parseSessionQuotaResetAt,
+  resolveQuotaFallbackAgent,
+  getAgentSetupInfo,
+  listAgentSetupInfo,
+  openInSystemTerminal,
+  installAgent,
+  loginAgent,
+  getAdapter,
+  allAdapters
+};