@sideboard-ai/core 0.1.62 → 0.1.67

package/dist/mcp/run-stdio.cjs

@@ -1507,18 +1507,37 @@ var init_gh_errors = __esm({
 });
 
 // src/agents/path.ts
+function prependPathDir(env, dir) {
+  if (!dir || !(0, import_node_fs4.existsSync)(dir)) return;
+  const current = env.PATH ?? "";
+  const parts = current.split(import_node_path4.delimiter).filter(Boolean);
+  if (parts.includes(dir)) {
+    env.PATH = current;
+    return;
+  }
+  env.PATH = [dir, ...parts].join(import_node_path4.delimiter);
+}
+function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os3.homedir)()) {
+  return (0, import_node_path4.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
+}
+function isConductorBundledCli(filePath) {
+  const p = (filePath ?? "").replace(/\\/g, "/");
+  return p.includes("/com.conductor.app/bin/") || p.endsWith("/com.conductor.app/bin");
+}
 function ensureAgentPath(env = process.env) {
   const home = env.HOME || env.USERPROFILE || (0, import_node_os3.homedir)();
   const current = env.PATH ?? "";
   const parts = current.split(import_node_path4.delimiter).filter(Boolean);
   const seen = new Set(parts);
   const extras = [
-    ...EXTRA_BIN_DIRS.map((rel) => `${home}/${rel}`),
+    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path4.join)(home, rel)),
     "/opt/homebrew/bin",
-    "/usr/local/bin"
+    "/usr/local/bin",
+    // Keep after Homebrew/npm so a user-installed CLI still wins.
+    conductorBundledBinDir(home)
   ];
   for (const dir of extras.reverse()) {
-    if (!dir || seen.has(dir)) continue;
+    if (!dir || seen.has(dir) || !(0, import_node_fs4.existsSync)(dir)) continue;
     parts.unshift(dir);
     seen.add(dir);
   }
@@ -1526,10 +1545,50 @@ function ensureAgentPath(env = process.env) {
   env.PATH = next;
   return next;
 }
-var import_node_os3, import_node_path4, EXTRA_BIN_DIRS;
+function enrichPathWithNpmGlobalBin(env = process.env) {
+  ensureAgentPath(env);
+  try {
+    const prefix = (0, import_node_child_process.execFileSync)("npm", ["prefix", "-g"], {
+      encoding: "utf8",
+      env: { ...process.env, ...env },
+      timeout: 8e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim().split(/\r?\n/).find(Boolean);
+    if (prefix) {
+      const binDir = process.platform === "win32" ? prefix : (0, import_node_path4.join)(prefix, "bin");
+      prependPathDir(env, binDir);
+    }
+  } catch {
+  }
+  return env.PATH ?? "";
+}
+function posixShellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveCommandBinarySync(command, whichPath) {
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
+  if (!match) return trimmed;
+  const bin = match[1];
+  const rest = match[2] ?? "";
+  if (bin.includes("/") || bin.includes("\\")) return trimmed;
+  const abs = whichPath?.trim().split(/\r?\n/).find(Boolean);
+  if (!abs) return trimmed;
+  return `${abs}${rest}`;
+}
+function withExportedPath(command, pathValue) {
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
+  return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
+}
+var import_node_fs4, import_node_child_process, import_node_os3, import_node_path4, EXTRA_BIN_DIRS;
 var init_path = __esm({
   "src/agents/path.ts"() {
     "use strict";
+    import_node_fs4 = require("fs");
+    import_node_child_process = require("child_process");
     import_node_os3 = require("os");
     import_node_path4 = require("path");
     EXTRA_BIN_DIRS = [
@@ -1537,6 +1596,10 @@ var init_path = __esm({
       ".cargo/bin",
       ".nvm/current/bin",
       ".asdf/shims",
+      ".volta/bin",
+      ".npm-global/bin",
+      // fnm default alias (common when shell init is skipped)
+      ".local/share/fnm/aliases/default/bin",
       // pnpm / npm global bins (where `@brightsy/cli` typically lands)
       "Library/pnpm",
       ".pnpm"
@@ -2596,7 +2659,7 @@ function isLocalPrFetchBranch(ref) {
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
   const worktreePath = (0, import_node_path5.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs4.existsSync)(worktreePath)) {
+  if ((0, import_node_fs5.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -2666,7 +2729,7 @@ async function createExistingBranchWorktree(opts) {
   const branchName = opts.branchName.trim();
   if (!branchName) throw new Error("branch name required");
   const worktreePath = (0, import_node_path5.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs4.existsSync)(worktreePath)) {
+  if ((0, import_node_fs5.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -2927,9 +2990,9 @@ function sameRepoPath(a, b) {
 }
 function listLocalThreadBranchSlugs(repoPath) {
   const refsDir = (0, import_node_path5.join)(repoPath, ".git", "refs", "heads", "thread");
-  if (!(0, import_node_fs4.existsSync)(refsDir)) return [];
+  if (!(0, import_node_fs5.existsSync)(refsDir)) return [];
   try {
-    return (0, import_node_fs4.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+    return (0, import_node_fs5.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
     return [];
   }
@@ -2937,8 +3000,8 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if ((0, import_node_fs4.existsSync)(root)) {
-    for (const entry of (0, import_node_fs4.readdirSync)(root, { withFileTypes: true })) {
+  if ((0, import_node_fs5.existsSync)(root)) {
+    for (const entry of (0, import_node_fs5.readdirSync)(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         taken.add(normalizeTakenSlug(entry.name));
       }
@@ -2960,16 +3023,16 @@ function allocateTeamSlug(repoPath) {
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
     const path = (0, import_node_path5.join)(worktreesRoot(repoPath), team.slug);
-    if (!(0, import_node_fs4.existsSync)(path)) return team;
+    if (!(0, import_node_fs5.existsSync)(path)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");
 }
-var import_node_fs4, import_node_path5;
+var import_node_fs5, import_node_path5;
 var init_worktree = __esm({
   "src/git/worktree.ts"() {
     "use strict";
-    import_node_fs4 = require("fs");
+    import_node_fs5 = require("fs");
     import_node_path5 = require("path");
     init_paths();
     init_thread_store();
@@ -2997,6 +3060,7 @@ __export(app_settings_exports, {
   autoRunAfterSetupEnabled: () => autoRunAfterSetupEnabled,
   brightsyCloudConnectAgent: () => brightsyCloudConnectAgent,
   brightsyCloudConnectEnabled: () => brightsyCloudConnectEnabled,
+  brightsyInjectWorktreeMcpEnabled: () => brightsyInjectWorktreeMcpEnabled,
   caffeinateWhileCloudConnectEnabled: () => caffeinateWhileCloudConnectEnabled,
   caffeinateWhileRunningEnabled: () => caffeinateWhileRunningEnabled,
   childEnvWithAppSettings: () => childEnvWithAppSettings,
@@ -3015,17 +3079,21 @@ __export(app_settings_exports, {
   maxConcurrentAgents: () => maxConcurrentAgents,
   orchestrationQuotaFallbackAgent: () => orchestrationQuotaFallbackAgent,
   orchestrationQuotaOnLimit: () => orchestrationQuotaOnLimit,
+  resolveAgentExecutable: () => resolveAgentExecutable,
   resolveClaudeExecutable: () => resolveClaudeExecutable,
   resolveEffectiveIssueSource: () => resolveEffectiveIssueSource,
   resolveNewThreadOptions: () => resolveNewThreadOptions,
   resolveThreadDefaults: () => resolveThreadDefaults,
   saveAppSettings: () => saveAppSettings,
   updateAdvancedSettings: () => updateAdvancedSettings,
+  updateAgentExecutable: () => updateAgentExecutable,
   updateAppEnvironment: () => updateAppEnvironment,
   updateBrightsySettings: () => updateBrightsySettings,
   updateClaudeSettings: () => updateClaudeSettings,
+  updateCodexSettings: () => updateCodexSettings,
   updateDefaultsSettings: () => updateDefaultsSettings,
-  updateIntegrationsSettings: () => updateIntegrationsSettings
+  updateIntegrationsSettings: () => updateIntegrationsSettings,
+  updateOpencodeSettings: () => updateOpencodeSettings
 });
 function appSettingsPath() {
   return (0, import_node_path6.join)(appDataDir(), "settings.json");
@@ -3046,16 +3114,33 @@ function normalizeClaude(raw) {
   }
   return out;
 }
+function normalizeCliExecutable(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.executablePath === "string") {
+    const path = source.executablePath.trim();
+    if (path) out.executablePath = path;
+  }
+  return out;
+}
 function normalizeBrightsy(raw) {
   if (!raw || typeof raw !== "object") return {};
   const source = raw;
   const out = {};
+  if (typeof source.executablePath === "string") {
+    const path = source.executablePath.trim();
+    if (path) out.executablePath = path;
+  }
   if (typeof source.cloudConnectEnabled === "boolean") {
     out.cloudConnectEnabled = source.cloudConnectEnabled;
   }
   if (typeof source.cloudConnectAgent === "string" && CLOUD_CONNECT_AGENTS.has(source.cloudConnectAgent)) {
     out.cloudConnectAgent = source.cloudConnectAgent;
   }
+  if (typeof source.injectWorktreeMcp === "boolean") {
+    out.injectWorktreeMcp = source.injectWorktreeMcp;
+  }
   return out;
 }
 function normalizeIntegrations(raw) {
@@ -3141,6 +3226,8 @@ function normalizeAdvanced(raw) {
 function normalizeSettings(raw) {
   const env = {};
   let claude = {};
+  let codex = {};
+  let opencode = {};
   let brightsy = {};
   let integrations = {};
   let defaults = {};
@@ -3159,6 +3246,12 @@ function normalizeSettings(raw) {
     if ("claude" in raw) {
       claude = normalizeClaude(raw.claude);
     }
+    if ("codex" in raw) {
+      codex = normalizeCliExecutable(raw.codex);
+    }
+    if ("opencode" in raw) {
+      opencode = normalizeCliExecutable(raw.opencode);
+    }
     if ("brightsy" in raw) {
       brightsy = normalizeBrightsy(raw.brightsy);
     }
@@ -3174,15 +3267,24 @@ function normalizeSettings(raw) {
       advanced = normalizeAdvanced(raw.advanced);
     }
   }
-  return { environment: env, claude, brightsy, integrations, defaults, advanced };
+  return {
+    environment: env,
+    claude,
+    codex,
+    opencode,
+    brightsy,
+    integrations,
+    defaults,
+    advanced
+  };
 }
 function loadAppSettings() {
   const path = appSettingsPath();
-  if (!(0, import_node_fs5.existsSync)(path)) {
+  if (!(0, import_node_fs6.existsSync)(path)) {
     return { ...EMPTY_SETTINGS };
   }
   try {
-    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(path, "utf8"));
     return normalizeSettings(parsed);
   } catch {
     return { ...EMPTY_SETTINGS };
@@ -3190,8 +3292,8 @@ function loadAppSettings() {
 }
 function saveAppSettings(settings) {
   const normalized = normalizeSettings(settings);
-  (0, import_node_fs5.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs5.writeFileSync)(appSettingsPath(), `${JSON.stringify(normalized, null, 2)}
+  (0, import_node_fs6.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs6.writeFileSync)(appSettingsPath(), `${JSON.stringify(normalized, null, 2)}
 `, "utf8");
   return normalized;
 }
@@ -3227,6 +3329,13 @@ function updateClaudeSettings(patch) {
 function updateBrightsySettings(patch) {
   const current = loadAppSettings();
   const brightsy = { ...current.brightsy };
+  if ("executablePath" in patch) {
+    if (patch.executablePath == null || patch.executablePath.trim() === "") {
+      delete brightsy.executablePath;
+    } else {
+      brightsy.executablePath = patch.executablePath.trim();
+    }
+  }
   if (typeof patch.cloudConnectEnabled === "boolean") {
     brightsy.cloudConnectEnabled = patch.cloudConnectEnabled;
   }
@@ -3237,8 +3346,35 @@ function updateBrightsySettings(patch) {
       brightsy.cloudConnectAgent = patch.cloudConnectAgent;
     }
   }
+  if (typeof patch.injectWorktreeMcp === "boolean") {
+    brightsy.injectWorktreeMcp = patch.injectWorktreeMcp;
+  }
   return saveAppSettings({ ...current, brightsy });
 }
+function updateCodexSettings(patch) {
+  const current = loadAppSettings();
+  const codex = { ...current.codex };
+  if ("executablePath" in patch) {
+    if (patch.executablePath == null || patch.executablePath.trim() === "") {
+      delete codex.executablePath;
+    } else {
+      codex.executablePath = patch.executablePath.trim();
+    }
+  }
+  return saveAppSettings({ ...current, codex });
+}
+function updateOpencodeSettings(patch) {
+  const current = loadAppSettings();
+  const opencode = { ...current.opencode };
+  if ("executablePath" in patch) {
+    if (patch.executablePath == null || patch.executablePath.trim() === "") {
+      delete opencode.executablePath;
+    } else {
+      opencode.executablePath = patch.executablePath.trim();
+    }
+  }
+  return saveAppSettings({ ...current, opencode });
+}
 function updateIntegrationsSettings(patch) {
   const current = loadAppSettings();
   const integrations = { ...current.integrations };
@@ -3346,6 +3482,9 @@ function getLinearApiKey(settings = loadAppSettings()) {
 function brightsyCloudConnectEnabled(settings = loadAppSettings()) {
   return Boolean(settings.brightsy.cloudConnectEnabled);
 }
+function brightsyInjectWorktreeMcpEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.brightsy.injectWorktreeMcp);
+}
 function brightsyCloudConnectAgent(settings = loadAppSettings()) {
   const fallback = settings.brightsy.cloudConnectAgent && CLOUD_CONNECT_AGENTS.has(settings.brightsy.cloudConnectAgent) ? settings.brightsy.cloudConnectAgent : "claude";
   const preferred = getDefaultAgent(settings);
@@ -3440,8 +3579,36 @@ function maxConcurrentAgents(settings = loadAppSettings()) {
   return 3;
 }
 function resolveClaudeExecutable(settings = loadAppSettings()) {
-  const override = settings.claude.executablePath?.trim();
-  return override || "claude";
+  return resolveAgentExecutable("claude", settings);
+}
+function resolveAgentExecutable(agent, settings = loadAppSettings()) {
+  const fallback = DEFAULT_CLI_BIN[agent];
+  if (agent === "claude") {
+    const override2 = settings.claude.executablePath?.trim();
+    return override2 || fallback;
+  }
+  if (agent === "codex") {
+    const override2 = settings.codex.executablePath?.trim();
+    return override2 || fallback;
+  }
+  if (agent === "opencode") {
+    const override2 = settings.opencode.executablePath?.trim();
+    return override2 || fallback;
+  }
+  const override = settings.brightsy.executablePath?.trim();
+  return override || fallback;
+}
+function updateAgentExecutable(agent, executablePath) {
+  if (agent === "claude") {
+    return updateClaudeSettings({ executablePath });
+  }
+  if (agent === "codex") {
+    return updateCodexSettings({ executablePath });
+  }
+  if (agent === "opencode") {
+    return updateOpencodeSettings({ executablePath });
+  }
+  return updateBrightsySettings({ executablePath });
 }
 function claudeChromeEnabled(settings = loadAppSettings()) {
   return Boolean(settings.claude.chromeEnabled);
@@ -3469,11 +3636,11 @@ function childEnvWithAppSettings(extra) {
 function harnessEnvKey(harness) {
   return HARNESS_ENV_KEYS[harness];
 }
-var import_node_fs5, import_node_os4, import_node_path6, HARNESS_ENV_KEYS, DEFAULT_AGENTS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, EMPTY_SETTINGS;
+var import_node_fs6, import_node_os4, import_node_path6, HARNESS_ENV_KEYS, DEFAULT_AGENTS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
 var init_app_settings = __esm({
   "src/store/app-settings.ts"() {
     "use strict";
-    import_node_fs5 = require("fs");
+    import_node_fs6 = require("fs");
     import_node_os4 = require("os");
     import_node_path6 = require("path");
     init_thinking_effort();
@@ -3502,11 +3669,19 @@ var init_app_settings = __esm({
     EMPTY_SETTINGS = {
       environment: {},
       claude: {},
+      codex: {},
+      opencode: {},
       brightsy: {},
       integrations: {},
       defaults: {},
       advanced: {}
     };
+    DEFAULT_CLI_BIN = {
+      claude: "claude",
+      codex: "codex",
+      opencode: "opencode",
+      brightsy: "brightsy"
+    };
   }
 });
 
@@ -3632,7 +3807,7 @@ function coordinatorTurnReminder(opts) {
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -3640,7 +3815,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs6.readFileSync)((0, import_node_path7.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs7.readFileSync)((0, import_node_path7.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -3682,9 +3857,9 @@ function ensureGlobalCoordinatorCwd(opts) {
     "Always ask worktree agents to open draft PRs (`send_to_thread` + `gh pr create --draft -R <origin>`); never open PRs from the orchestrator."
   ].join("\n");
   try {
-    (0, import_node_fs6.writeFileSync)((0, import_node_path7.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs7.writeFileSync)((0, import_node_path7.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs6.writeFileSync)((0, import_node_path7.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs7.writeFileSync)((0, import_node_path7.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -3717,11 +3892,11 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs6, import_node_path7, COORDINATOR_TOOL_PLAYBOOK;
+var import_node_fs7, import_node_path7, COORDINATOR_TOOL_PLAYBOOK;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
+    import_node_fs7 = require("fs");
     import_node_path7 = require("path");
     init_worktree();
     init_app_settings();
@@ -3947,26 +4122,26 @@ function brightsyConfigPath() {
 }
 function loadBrightsyConfig() {
   const path = brightsyConfigPath();
-  if (!(0, import_node_fs7.existsSync)(path)) {
+  if (!(0, import_node_fs8.existsSync)(path)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+  const raw = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
   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_fs7.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs8.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs7, import_node_os5, import_node_path8;
+var import_node_fs8, import_node_os5, import_node_path8;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs7 = require("fs");
+    import_node_fs8 = require("fs");
     import_node_os5 = require("os");
     import_node_path8 = require("path");
   }
@@ -3987,18 +4162,18 @@ function storePath() {
 }
 function readStore() {
   const path = storePath();
-  if (!(0, import_node_fs8.existsSync)(path)) return [];
+  if (!(0, import_node_fs9.existsSync)(path)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(path, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore(teams) {
-  (0, import_node_fs8.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs9.mkdirSync)(appDataDir(), { recursive: true });
   const path = storePath();
-  (0, import_node_fs8.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs9.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -4110,11 +4285,11 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs8, import_node_path9;
+var import_node_fs9, import_node_path9;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.ts"() {
     "use strict";
-    import_node_fs8 = require("fs");
+    import_node_fs9 = require("fs");
     import_node_path9 = require("path");
     init_paths();
     init_accounts();
@@ -4162,6 +4337,11 @@ function normalizeTurnInput(input) {
   if (typeof input === "string") return { prompt: input };
   return { prompt: input.prompt, cachedPrefix: input.cachedPrefix?.trim() || void 0 };
 }
+function dropCachedPrefixOnResume(input, sessionId) {
+  const turn = normalizeTurnInput(input);
+  if (sessionId) return { prompt: turn.prompt };
+  return turn;
+}
 function flattenTurnInput(input) {
   const { cachedPrefix, prompt } = normalizeTurnInput(input);
   if (!cachedPrefix) return prompt;
@@ -4306,9 +4486,13 @@ async function fetchTeamChatTargets(team) {
   };
 }
 async function listBrightsyChatTargetsViaCli() {
-  const listed = await run("brightsy", ["chat", "--list-targets", "--json"], {
-    reject: false
-  });
+  const listed = await run(
+    resolveAgentExecutable("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?"
@@ -4392,13 +4576,15 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var brightsyAdapter;
+var import_node_fs10, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
+    import_node_fs10 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
+    init_app_settings();
     init_brightsy_targets();
     init_error_detail();
     init_turn_input();
@@ -4406,18 +4592,32 @@ var init_brightsy = __esm({
     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 brightsy = resolveAgentExecutable("brightsy");
+        if (brightsy !== "brightsy") {
+          if (!(0, import_node_fs10.existsSync)(brightsy)) {
+            return {
+              agent: "brightsy",
+              installed: false,
+              authenticated: false,
+              linearMcp: false,
+              warnings: [],
+              reason: `Brightsy executable not found: ${brightsy}`
+            };
+          }
+        } else {
+          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 who = await run(brightsy, ["whoami"], { reject: false });
         const authenticated = who.exitCode === 0 && /logged in as/i.test(who.stdout);
         return {
           agent: "brightsy",
@@ -4442,7 +4642,7 @@ var init_brightsy = __esm({
           target.id
         ];
         return {
-          file: "brightsy",
+          file: resolveAgentExecutable("brightsy"),
           args,
           cwd: thread.worktreePath,
           // Piped stdin becomes the message body (avoids ARG_MAX for long seeds).
@@ -4459,7 +4659,11 @@ var init_brightsy = __esm({
         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 };
+        return {
+          file: resolveAgentExecutable("brightsy"),
+          args,
+          cwd: thread.worktreePath
+        };
       }
     };
   }
@@ -4504,6 +4708,18 @@ var init_claude_mcp = __esm({
   }
 });
 
+// src/mcp/profile.ts
+function sideboardMcpProfile(env = process.env) {
+  return env[SIDEBOARD_MCP_PROFILE_ENV]?.trim().toLowerCase() === "worktree" ? "worktree" : "orchestration";
+}
+var SIDEBOARD_MCP_PROFILE_ENV;
+var init_profile = __esm({
+  "src/mcp/profile.ts"() {
+    "use strict";
+    SIDEBOARD_MCP_PROFILE_ENV = "SIDEBOARD_MCP_PROFILE";
+  }
+});
+
 // src/agents/node-launch.ts
 function isAsarPath(filePath) {
   return /\.asar([/\\]|$)/.test(filePath);
@@ -4551,6 +4767,38 @@ function isBrightsyConnected() {
     return false;
   }
 }
+function promptMentionsBrightsy(text) {
+  return BRIGHTSY_WORD.test(text ?? "");
+}
+function isBrightsyMcpToolName(name) {
+  const n = name.toLowerCase();
+  return n === "brightsy" || n.startsWith("mcp__brightsy") || n.startsWith("brightsy_");
+}
+function toolInputUsesBrightsyDatasource(input) {
+  const ds = input?.datasource;
+  return typeof ds === "string" && ds.toLowerCase() === "brightsy";
+}
+function messageUsedBrightsyMcp(msg) {
+  if (msg.role === "user" && promptMentionsBrightsy(msg.text)) return true;
+  for (const part of msg.parts ?? []) {
+    if (part.type !== "tool") continue;
+    if (isBrightsyMcpToolName(part.name)) return true;
+    if (/present_(schema|files)$/i.test(part.name) && toolInputUsesBrightsyDatasource(part.input)) {
+      return true;
+    }
+  }
+  return false;
+}
+function threadRequestsBrightsyMcp(thread) {
+  return (thread?.messages ?? []).some(messageUsedBrightsyMcp);
+}
+function shouldInjectBrightsyMcp(thread, opts) {
+  if (!(opts?.connected ?? isBrightsyConnected())) return false;
+  if (opts?.orchestrator) return true;
+  const alwaysOn = opts?.alwaysOnWorktree ?? Boolean(loadAppSettings().brightsy?.injectWorktreeMcp);
+  if (alwaysOn) return true;
+  return threadRequestsBrightsyMcp(thread);
+}
 function mcpLaunch(cmd, name, env) {
   if (cmd === "brightsy-mcp") {
     return { name, command: "brightsy-mcp", ...env ? { env } : {} };
@@ -4596,7 +4844,7 @@ function corePackageDir() {
 }
 function findSideboardMcpJsEntry() {
   const override = process.env.SIDEBOARD_MCP_ENTRY?.trim() || process.env.SIDEBOARD_CLI?.trim();
-  if (override && (0, import_node_fs9.existsSync)(override)) return override;
+  if (override && (0, import_node_fs11.existsSync)(override)) return override;
   let dir = corePackageDir();
   for (let i = 0; i < 10; i++) {
     const candidates = [
@@ -4609,7 +4857,7 @@ function findSideboardMcpJsEntry() {
       (0, import_node_path10.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs9.existsSync)(p)) return p;
+      if ((0, import_node_fs11.existsSync)(p)) return p;
     }
     const parent = (0, import_node_path10.dirname)(dir);
     if (parent === dir) break;
@@ -4640,11 +4888,13 @@ async function buildInjectedMcpServers(opts) {
   const servers = [];
   if (opts.includeSideboard) {
     const sideboard = await resolveSideboardMcpServer();
+    const orchId = opts.orchestratorThreadId?.trim();
+    const profile = orchId ? "orchestration" : "worktree";
     sideboard.env = {
       ...sideboard.env ?? {},
-      SIDEBOARD_APP_DATA: appDataDir()
+      SIDEBOARD_APP_DATA: appDataDir(),
+      [SIDEBOARD_MCP_PROFILE_ENV]: profile
     };
-    const orchId = opts.orchestratorThreadId?.trim();
     if (orchId) {
       sideboard.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID = orchId;
     }
@@ -4719,16 +4969,16 @@ function writeMcpServersConfig(servers) {
       ...s.env ? { env: s.env } : {}
     };
   }
-  const dir = (0, import_node_fs9.mkdtempSync)((0, import_node_path10.join)((0, import_node_os6.tmpdir)(), "sideboard-mcp-"));
+  const dir = (0, import_node_fs11.mkdtempSync)((0, import_node_path10.join)((0, import_node_os6.tmpdir)(), "sideboard-mcp-"));
   const cfgPath = (0, import_node_path10.join)(dir, "mcp.json");
-  (0, import_node_fs9.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  (0, import_node_fs11.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
-var import_node_fs9, import_node_module, import_node_os6, import_node_path10, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache;
+var import_node_fs11, import_node_module, import_node_os6, import_node_path10, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
 var init_injected_mcp = __esm({
   "src/agents/injected-mcp.ts"() {
     "use strict";
-    import_node_fs9 = require("fs");
+    import_node_fs11 = require("fs");
     import_node_module = require("module");
     import_node_os6 = require("os");
     import_node_path10 = require("path");
@@ -4736,6 +4986,8 @@ var init_injected_mcp = __esm({
     init_run();
     init_config();
     init_connected_teams();
+    init_profile();
+    init_app_settings();
     init_paths();
     init_node_launch();
     import_meta = {};
@@ -4751,6 +5003,7 @@ var init_injected_mcp = __esm({
       "mcp__sideboard__present_plan"
     ];
     brightsyMcpCommandCache = null;
+    BRIGHTSY_WORD = /(?<![a-z0-9_-])brightsy(?![a-z0-9_-])/i;
   }
 });
 
@@ -4905,11 +5158,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs10, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs12, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
+    import_node_fs12 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -4938,7 +5191,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs10.existsSync)(claude)) {
+          if (!(0, import_node_fs12.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -4977,9 +5230,8 @@ var init_claude = __esm({
       },
       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 effective = dropCachedPrefixOnResume(input, sessionId);
         const promptText = flattenTurnInput(effective);
         const useStdin = promptText.length > CLAUDE_PROMPT_ARG_MAX;
         if (process.env.SIDEBOARD_DEBUG_CLAUDE_TURN === "1") {
@@ -4992,7 +5244,9 @@ var init_claude = __esm({
         const isOrchestrator = isOrchestratorThread2(thread);
         const injectedServers = await buildInjectedMcpServers({
           includeSideboard: true,
-          includeBrightsy: isBrightsyConnected(),
+          includeBrightsy: shouldInjectBrightsyMcp(thread, {
+            orchestrator: isOrchestrator
+          }),
           orchestratorThreadId: isOrchestrator ? thread.id : null
         });
         const injectedBrightsyNames = injectedServers.filter((s) => s.name === "brightsy" || s.name.startsWith("brightsy_")).map((s) => s.name);
@@ -5166,9 +5420,14 @@ async function listCodexModels() {
   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 });
+  const codex = resolveAgentExecutable("codex");
+  if (codex === "codex") {
+    const which = await run("which", ["codex"], { reject: false });
+    if (which.exitCode !== 0) return FALLBACK_CODEX_MODELS;
+  } else if (!(0, import_node_fs13.existsSync)(codex)) {
+    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;
   }
@@ -5207,8 +5466,8 @@ function codexConfigHasNetworkAccess() {
     (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path of candidates) {
-    if (!(0, import_node_fs11.existsSync)(path)) continue;
-    const text = (0, import_node_fs11.readFileSync)(path, "utf8");
+    if (!(0, import_node_fs13.existsSync)(path)) continue;
+    const text = (0, import_node_fs13.readFileSync)(path, "utf8");
     if (/network_access\s*=\s*true/.test(text)) return true;
   }
   return false;
@@ -5241,21 +5500,23 @@ function asRecord(value) {
 }
 function codexLooksAuthenticated() {
   const authPath = (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs11.existsSync)(authPath)) return false;
+  if (!(0, import_node_fs13.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs11.statSync)(authPath).size > 2;
+    return (0, import_node_fs13.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs11, import_node_os7, import_node_path11, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs13, import_node_os7, import_node_path11, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
 var init_codex = __esm({
   "src/agents/codex.ts"() {
     "use strict";
-    import_node_fs11 = require("fs");
+    import_node_fs13 = require("fs");
     import_node_os7 = require("os");
     import_node_path11 = require("path");
     init_run();
+    init_app_settings();
+    init_global_workspace();
     init_error_detail();
     init_injected_mcp();
     init_turn_input();
@@ -5273,16 +5534,30 @@ var init_codex = __esm({
     codexAdapter = {
       kind: "codex",
       async detect() {
-        const which = await run("which", ["codex"], { reject: false, timeoutMs: 3e3 });
-        if (which.exitCode !== 0) {
-          return {
-            agent: "codex",
-            installed: false,
-            authenticated: false,
-            linearMcp: false,
-            warnings: [],
-            reason: "codex CLI not found on PATH"
-          };
+        const codex = resolveAgentExecutable("codex");
+        if (codex !== "codex") {
+          if (!(0, import_node_fs13.existsSync)(codex)) {
+            return {
+              agent: "codex",
+              installed: false,
+              authenticated: false,
+              linearMcp: false,
+              warnings: [],
+              reason: `Codex executable not found: ${codex}`
+            };
+          }
+        } else {
+          const which = await run("which", ["codex"], { reject: false, timeoutMs: 3e3 });
+          if (which.exitCode !== 0) {
+            return {
+              agent: "codex",
+              installed: false,
+              authenticated: false,
+              linearMcp: false,
+              warnings: [],
+              reason: "codex CLI not found on PATH"
+            };
+          }
         }
         const authenticated = codexLooksAuthenticated();
         const linearMcp = false;
@@ -5302,22 +5577,24 @@ var init_codex = __esm({
         };
       },
       async buildTurn(thread, input) {
-        const prompt = flattenTurnInput(input);
         const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+        const prompt = flattenTurnInput(dropCachedPrefixOnResume(input, 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)}`
+            `[sideboard/codex] promptChars=${prompt.length} resumed=${Boolean(sessionId)} stdin=${useStdin} hasPrefix=${prompt.includes("Current request:")}`
           );
         }
         const mode = permissionMode(thread);
         const model = thread.model?.trim();
+        const isOrchestrator = isOrchestratorThread(thread);
         const injected = await buildInjectedMcpServers({
           includeSideboard: true,
-          includeBrightsy: isBrightsyConnected(),
-          orchestratorThreadId: thread.sourceType === "orchestration" ? thread.id : null
+          includeBrightsy: shouldInjectBrightsyMcp(thread, {
+            orchestrator: isOrchestrator
+          }),
+          orchestratorThreadId: isOrchestrator ? thread.id : null
         });
         const mcpOverrides = toCodexMcpConfigArgs(injected);
         const execOpts = [
@@ -5337,7 +5614,7 @@ var init_codex = __esm({
         ];
         const args = sessionId ? ["exec", ...execOpts, "resume", sessionId, promptArg] : ["exec", ...execOpts, promptArg];
         return {
-          file: "codex",
+          file: resolveAgentExecutable("codex"),
           args,
           cwd: thread.worktreePath,
           stdin: useStdin ? `${prompt}
@@ -5433,16 +5710,17 @@ var init_codex = __esm({
         return cached;
       },
       async buildAttach(thread) {
+        const codex = resolveAgentExecutable("codex");
         const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
         if (sessionId) {
           return {
-            file: "codex",
+            file: codex,
             args: ["exec", "--cd", thread.worktreePath, "resume", sessionId],
             cwd: thread.worktreePath
           };
         }
         return {
-          file: "codex",
+          file: codex,
           args: ["--cd", thread.worktreePath],
           cwd: thread.worktreePath
         };
@@ -5450,7 +5728,7 @@ var init_codex = __esm({
       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",
+          resolveAgentExecutable("codex"),
           [
             "exec",
             "--json",
@@ -5713,21 +5991,22 @@ function cursorRunnerPath() {
     (0, import_node_path12.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs12.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs14.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs12, import_node_module2, import_node_path12, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs14, import_node_module2, import_node_path12, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
 var init_cursor = __esm({
   "src/agents/cursor.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
+    import_node_fs14 = require("fs");
     import_node_module2 = require("module");
     import_node_path12 = require("path");
     import_node_url2 = require("url");
     import_sdk = require("@cursor/sdk");
     init_run();
     init_app_settings();
+    init_global_workspace();
     init_cursor_events();
     init_injected_mcp();
     init_node_launch();
@@ -5764,13 +6043,16 @@ var init_cursor = __esm({
         };
       },
       async buildTurn(thread, input) {
-        const prompt = flattenTurnInput(input);
         const agentId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+        const prompt = flattenTurnInput(dropCachedPrefixOnResume(input, agentId));
         const apiKey = resolveCursorApiKey() || void 0;
+        const isOrchestrator = isOrchestratorThread(thread);
         const injected = await buildInjectedMcpServers({
           includeSideboard: true,
-          includeBrightsy: isBrightsyConnected(),
-          orchestratorThreadId: thread.sourceType === "orchestration" ? thread.id : null
+          includeBrightsy: shouldInjectBrightsyMcp(thread, {
+            orchestrator: isOrchestrator
+          }),
+          orchestratorThreadId: isOrchestrator ? thread.id : null
         });
         const mcpServers = toCursorMcpServers(injected);
         const req = {
@@ -5841,9 +6123,14 @@ async function listOpencodeModels() {
   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 });
+  const opencode = resolveAgentExecutable("opencode");
+  if (opencode === "opencode") {
+    const which = await run("which", ["opencode"], { reject: false });
+    if (which.exitCode !== 0) return FALLBACK_OPENCODE_MODELS;
+  } else if (!(0, import_node_fs15.existsSync)(opencode)) {
+    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;
   }
@@ -5870,11 +6157,14 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs15, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
+    import_node_fs15 = require("fs");
     init_run();
+    init_app_settings();
+    init_global_workspace();
     init_error_detail();
     init_injected_mcp();
     init_turn_input();
@@ -5895,20 +6185,34 @@ var init_opencode = __esm({
     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 opencode = resolveAgentExecutable("opencode");
+        if (opencode !== "opencode") {
+          if (!(0, import_node_fs15.existsSync)(opencode)) {
+            return {
+              agent: "opencode",
+              installed: false,
+              authenticated: false,
+              linearMcp: false,
+              warnings: [],
+              reason: `OpenCode executable not found: ${opencode}`
+            };
+          }
+        } else {
+          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 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 mcp = await run(opencode, ["mcp", "list"], { reject: false });
         const linearMcp = /linear/i.test(mcp.stdout + mcp.stderr);
         return {
           agent: "opencode",
@@ -5920,8 +6224,8 @@ var init_opencode = __esm({
         };
       },
       async buildTurn(thread, input) {
-        const prompt = flattenTurnInput(input);
         const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+        const prompt = flattenTurnInput(dropCachedPrefixOnResume(input, sessionId));
         const mode = permissionMode(thread);
         const model = thread.model?.trim();
         const args = [
@@ -5937,14 +6241,17 @@ var init_opencode = __esm({
         if (model) {
           args.push("--model", model);
         }
+        const isOrchestrator = isOrchestratorThread(thread);
         const injected = await buildInjectedMcpServers({
           includeSideboard: true,
-          includeBrightsy: isBrightsyConnected(),
-          orchestratorThreadId: thread.sourceType === "orchestration" ? thread.id : null
+          includeBrightsy: shouldInjectBrightsyMcp(thread, {
+            orchestrator: isOrchestrator
+          }),
+          orchestratorThreadId: isOrchestrator ? thread.id : null
         });
         const mcpContent = injected.length > 0 ? toOpencodeMcpConfigContent(injected) : null;
         return {
-          file: "opencode",
+          file: resolveAgentExecutable("opencode"),
           args,
           cwd: thread.worktreePath,
           // `opencode run` treats non-TTY stdin as the message body when no positional
@@ -6020,7 +6327,7 @@ var init_opencode = __esm({
       async resolveSessionId(worktreePath, cached) {
         const cachedId = cached?.trim() || null;
         const listed = await run(
-          "opencode",
+          resolveAgentExecutable("opencode"),
           ["session", "list", "--format", "json"],
           { cwd: worktreePath, reject: false }
         );
@@ -6051,7 +6358,7 @@ var init_opencode = __esm({
         const args = ["--dir", thread.worktreePath];
         if (sessionId) args.push("--session", sessionId);
         return {
-          file: "opencode",
+          file: resolveAgentExecutable("opencode"),
           args,
           cwd: thread.worktreePath,
           env: {
@@ -6062,7 +6369,7 @@ var init_opencode = __esm({
       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",
+          resolveAgentExecutable("opencode"),
           ["run", prompt, "--format", "json"],
           {
             reject: false,
@@ -6295,9 +6602,30 @@ function getAgentSetupInfo(agent) {
 function listAgentSetupInfo() {
   return Object.values(SETUP);
 }
-async function openInSystemTerminal(command) {
-  ensureAgentPath();
+function resolveLoginCommand(agent) {
+  const info = getAgentSetupInfo(agent);
+  if (!info.loginCommand) return null;
+  if (!CLI_LOGIN_AGENTS.has(agent)) return info.loginCommand;
+  const exe = resolveAgentExecutable(agent);
+  return info.loginCommand.replace(/^\S+/, exe);
+}
+async function prepareTerminalCommand(command) {
+  enrichPathWithNpmGlobalBin();
   const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
+  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
+  const bin = match?.[1];
+  let whichPath = null;
+  if (bin && !bin.includes("/") && !bin.includes("\\")) {
+    const which = await run("which", [bin], { reject: false, timeoutMs: 3e3 });
+    whichPath = which.exitCode === 0 ? which.stdout.trim() : null;
+  }
+  const resolved = resolveCommandBinarySync(trimmed, whichPath);
+  return withExportedPath(resolved, process.env.PATH ?? "");
+}
+async function openInSystemTerminal(command) {
+  const trimmed = (await prepareTerminalCommand(command)).trim();
   if (!trimmed) throw new Error("Command is empty");
   if (process.platform === "darwin") {
     const escaped = trimmed.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -6338,6 +6666,11 @@ async function openInSystemTerminal(command) {
     `No terminal found to run: ${trimmed}. Install gnome-terminal (or similar), or run the command manually.`
   );
 }
+async function whichCli(bin) {
+  const which = await run("which", [bin], { reject: false, timeoutMs: 3e3 });
+  if (which.exitCode !== 0) return null;
+  return which.stdout.trim().split(/\r?\n/).find(Boolean) ?? null;
+}
 async function installAgent(agent) {
   const info = getAgentSetupInfo(agent);
   if (info.kind === "bundled-sdk" || info.kind === "api-key") {
@@ -6358,7 +6691,18 @@ async function installAgent(agent) {
       message: `Opened Terminal to run: ${info.installCommand}`
     };
   }
-  ensureAgentPath();
+  enrichPathWithNpmGlobalBin();
+  const cliBin = agent === "cursor" ? null : CLI_BIN[agent];
+  if (cliBin) {
+    const existing = await whichCli(cliBin);
+    if (existing) {
+      return {
+        ok: true,
+        command: existing,
+        message: isConductorBundledCli(existing) ? `Using Conductor\u2019s ${cliBin} at ${existing}. No extra install \u2014 Log in only if auth is missing.` : `Already on PATH: ${existing}`
+      };
+    }
+  }
   const result = await run("npm", ["install", "-g", info.npmPackage], { reject: false });
   const ok = result.exitCode === 0;
   if (!ok) {
@@ -6384,36 +6728,44 @@ async function installAgent(agent) {
       };
     }
   }
+  enrichPathWithNpmGlobalBin();
+  let binPath = null;
+  if (cliBin) {
+    binPath = await whichCli(cliBin);
+  }
   return {
     ok: true,
     command: info.installCommand,
     exitCode: 0,
     stdout: result.stdout,
     stderr: result.stderr,
-    message: `Installed ${info.npmPackage}`
+    message: binPath ? `Installed ${info.npmPackage} \u2192 ${binPath}` : `Installed ${info.npmPackage} (CLI not yet on PATH \u2014 Log in still exports Electron\u2019s PATH into Terminal)`
   };
 }
 async function loginAgent(agent) {
   const info = getAgentSetupInfo(agent);
-  if (!info.loginCommand) {
+  const loginCommand = resolveLoginCommand(agent);
+  if (!loginCommand) {
     return {
       ok: true,
       message: info.kind === "bundled-sdk" || info.kind === "api-key" ? info.summary : `No login command for ${agent}`
     };
   }
-  await openInSystemTerminal(info.loginCommand);
+  const prepared = await prepareTerminalCommand(loginCommand);
+  await openInSystemTerminal(prepared);
   return {
     ok: true,
     openedTerminal: true,
-    command: info.loginCommand,
-    message: `Opened Terminal to run: ${info.loginCommand}`
+    command: prepared,
+    message: `Opened Terminal to run: ${prepared}`
   };
 }
-var SETUP;
+var SETUP, CLI_BIN, CLI_LOGIN_AGENTS;
 var init_install = __esm({
   "src/agents/install.ts"() {
     "use strict";
     init_run();
+    init_app_settings();
     init_path();
     SETUP = {
       claude: {
@@ -6462,6 +6814,18 @@ var init_install = __esm({
         npmPackage: "@brightsy/cli"
       }
     };
+    CLI_BIN = {
+      claude: "claude",
+      codex: "codex",
+      opencode: "opencode",
+      brightsy: "brightsy"
+    };
+    CLI_LOGIN_AGENTS = /* @__PURE__ */ new Set([
+      "claude",
+      "codex",
+      "opencode",
+      "brightsy"
+    ]);
   }
 });
 
@@ -6477,14 +6841,17 @@ __export(agents_exports, {
   claudeAdapter: () => claudeAdapter,
   codexAdapter: () => codexAdapter,
   coerceOrchestratorAgent: () => coerceOrchestratorAgent,
+  conductorBundledBinDir: () => conductorBundledBinDir,
   cursorAdapter: () => cursorAdapter,
   cursorSdkMessageToEvents: () => cursorSdkMessageToEvents,
   decodeBrightsyTarget: () => decodeBrightsyTarget,
   encodeBrightsyTarget: () => encodeBrightsyTarget,
+  enrichPathWithNpmGlobalBin: () => enrichPathWithNpmGlobalBin,
   ensureAgentPath: () => ensureAgentPath,
   getAdapter: () => getAdapter,
   getAgentSetupInfo: () => getAgentSetupInfo,
   installAgent: () => installAgent,
+  isConductorBundledCli: () => isConductorBundledCli,
   isCursorAutoModel: () => isCursorAutoModel,
   isOrchestratorCapableAgent: () => isOrchestratorCapableAgent,
   isSessionQuotaLimit: () => isSessionQuotaLimit,
@@ -6500,8 +6867,13 @@ __export(agents_exports, {
   parseCursorRunnerLine: () => parseCursorRunnerLine,
   parseSessionQuotaResetAt: () => parseSessionQuotaResetAt,
   permissionMode: () => permissionMode,
+  posixShellSingleQuote: () => posixShellSingleQuote,
+  prepareTerminalCommand: () => prepareTerminalCommand,
+  resolveCommandBinarySync: () => resolveCommandBinarySync,
   resolveCursorModelId: () => resolveCursorModelId,
-  resolveQuotaFallbackAgent: () => resolveQuotaFallbackAgent
+  resolveLoginCommand: () => resolveLoginCommand,
+  resolveQuotaFallbackAgent: () => resolveQuotaFallbackAgent,
+  withExportedPath: () => withExportedPath
 });
 function getAdapter(kind) {
   return adapters[kind];
@@ -6559,31 +6931,31 @@ function removedWorkspacesFile() {
 }
 function readAll() {
   const path = workspacesFile();
-  if (!(0, import_node_fs16.existsSync)(path)) return [];
+  if (!(0, import_node_fs19.existsSync)(path)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs16.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll(list) {
-  (0, import_node_fs16.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs16.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs19.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path = removedWorkspacesFile();
-  if (!(0, import_node_fs16.existsSync)(path)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs19.existsSync)(path)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs16.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
     return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 function writeRemoved(paths) {
-  (0, import_node_fs16.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs16.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs19.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -6606,7 +6978,7 @@ function listWorkspaces() {
 async function addWorkspace(repoPath) {
   const root = await resolveRepoRoot(repoPath);
   if (!root || root === "/") throw new Error(`Invalid repo path: ${repoPath}`);
-  if (!(0, import_node_fs16.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs19.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll();
@@ -6636,7 +7008,7 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path || path === "/" || isGlobalRepoPath(path) || byPath.has(path) || removed.has(path)) {
       continue;
     }
-    if (!(0, import_node_fs16.existsSync)(path)) continue;
+    if (!(0, import_node_fs19.existsSync)(path)) continue;
     const ws = {
       path,
       name: (0, import_node_path16.basename)(path),
@@ -6649,11 +7021,11 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs16, import_node_path16;
+var import_node_fs19, import_node_path16;
 var init_workspaces = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs16 = require("fs");
+    import_node_fs19 = require("fs");
     import_node_path16 = require("path");
     init_paths();
     init_global_workspace();
@@ -6732,17 +7104,17 @@ __export(plan_file_exports, {
 });
 function ensureAttachmentsGitignore2(worktreePath) {
   const gitignoreAbs = (0, import_node_path24.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs26.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs26.mkdirSync)((0, import_node_path24.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs26.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  if ((0, import_node_fs29.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs29.mkdirSync)((0, import_node_path24.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs29.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
   return (0, import_node_path24.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs26.existsSync)(abs)) return null;
+  if (!(0, import_node_fs29.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs26.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs29.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
@@ -6754,16 +7126,16 @@ function readPlanFile(worktreePath) {
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore2(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs26.mkdirSync)((0, import_node_path24.dirname)(abs), { recursive: true });
+  (0, import_node_fs29.mkdirSync)((0, import_node_path24.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs26.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs29.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs26, import_node_path24;
+var import_node_fs29, import_node_path24;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs26 = require("fs");
+    import_node_fs29 = require("fs");
     import_node_path24 = require("path");
     init_workspace_scratch();
     init_plan_present();
@@ -6780,9 +7152,9 @@ function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
   const runsPath = (0, import_node_path25.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs27.existsSync)(runsPath)) return null;
+  if (!(0, import_node_fs30.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs27.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs30.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -6808,11 +7180,11 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs27, import_node_path25;
+var import_node_fs30, import_node_path25;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs27 = require("fs");
+    import_node_fs30 = require("fs");
     import_node_path25 = require("path");
     init_paths();
   }
@@ -6826,7 +7198,7 @@ var import_node_path26 = require("path");
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
-var import_node_fs28 = require("fs");
+var import_node_fs31 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -7216,7 +7588,7 @@ function shouldAutoArchiveOnPrMerge(opts) {
 }
 
 // src/hook/conductor.ts
-var import_node_fs13 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_net = require("net");
 var import_node_path13 = require("path");
 var import_execa3 = require("execa");
@@ -7229,8 +7601,8 @@ function matchSimpleGlob(pattern, name) {
 }
 function readWorktreeInclude(repoPath) {
   const path = (0, import_node_path13.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs13.existsSync)(path)) return [];
-  return (0, import_node_fs13.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  if (!(0, import_node_fs16.existsSync)(path)) return [];
+  return (0, import_node_fs16.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -7240,7 +7612,7 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs13.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs16.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
           if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path13.basename)(glob), entry.name)) {
@@ -7255,7 +7627,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs13.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs16.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -7270,10 +7642,10 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const copied = [];
   for (const rel of patterns) {
     const src = (0, import_node_path13.join)(repoPath, rel);
-    if (!(0, import_node_fs13.existsSync)(src)) continue;
+    if (!(0, import_node_fs16.existsSync)(src)) continue;
     const dest = (0, import_node_path13.join)(worktreePath, rel);
-    (0, import_node_fs13.mkdirSync)((0, import_node_path13.dirname)(dest), { recursive: true });
-    (0, import_node_fs13.copyFileSync)(src, dest);
+    (0, import_node_fs16.mkdirSync)((0, import_node_path13.dirname)(dest), { recursive: true });
+    (0, import_node_fs16.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -7526,15 +7898,15 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
 }
 
 // src/hook/cursor-worktrees.ts
-var import_node_fs14 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_path14 = require("path");
 var import_execa4 = require("execa");
 var import_node_readline3 = require("readline");
 function loadCursorWorktreesJson(rootPath) {
   const path = (0, import_node_path14.join)(rootPath, ".cursor", "worktrees.json");
-  if (!(0, import_node_fs14.existsSync)(path)) return null;
+  if (!(0, import_node_fs17.existsSync)(path)) return null;
   try {
-    return JSON.parse((0, import_node_fs14.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs17.readFileSync)(path, "utf8"));
   } catch {
     return null;
   }
@@ -7592,7 +7964,7 @@ async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
 }
 
 // src/git/orphan-cleanup.ts
-var import_node_fs15 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_path15 = require("path");
 init_worktree();
 init_thread_store();
@@ -7608,9 +7980,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs15.existsSync)(homeRoot)) {
+  if ((0, import_node_fs18.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs15.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs18.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -7620,7 +7992,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs15.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs18.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -7631,7 +8003,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs15.statSync)(path).mtimeMs;
+          mtimeMs = (0, import_node_fs18.statSync)(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -7641,16 +8013,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs15.existsSync)(root)) {
-        for (const entry of (0, import_node_fs15.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs18.existsSync)(root)) {
+        for (const entry of (0, import_node_fs18.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
           const path = (0, import_node_path15.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs15.existsSync)((0, import_node_path15.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs18.existsSync)((0, import_node_path15.join)(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs15.statSync)(path).mtimeMs;
+            mtimeMs = (0, import_node_fs18.statSync)(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -7787,7 +8159,7 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-var import_node_fs17 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_path17 = require("path");
 var import_execa6 = require("execa");
 init_paths();
@@ -7803,7 +8175,7 @@ async function cloneRepoIntoSideboard(opts) {
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
   const dest = (0, import_node_path17.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs17.existsSync)(dest)) {
+  if ((0, import_node_fs20.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -7823,13 +8195,14 @@ async function cloneRepoIntoSideboard(opts) {
 init_thread_store();
 
 // src/threads/create.ts
-var import_node_fs18 = require("fs");
+var import_node_fs21 = require("fs");
 
 // src/detect/detect.ts
 init_agents();
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
 async function requireAgent(agent, opts) {
   ensureAgentPath();
+  enrichPathWithNpmGlobalBin();
   const status = await Promise.race([
     getAdapter(agent).detect(),
     new Promise((_, reject) => {
@@ -7867,7 +8240,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs18.existsSync)(repoPath)) {
+  if (!(0, import_node_fs21.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -8330,7 +8703,7 @@ function forkChatTab(input) {
 
 // src/review/request-review.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs19 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_path18 = require("path");
 init_global_workspace();
 init_thread_store();
@@ -8475,9 +8848,9 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs19.existsSync)(abs)) return null;
+  if (!(0, import_node_fs22.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs19.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs22.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
@@ -8485,9 +8858,9 @@ function readTextIfPresent(abs) {
 }
 function ensureAttachmentsGitignore(worktreePath) {
   const gitignoreAbs = (0, import_node_path18.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs19.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs19.mkdirSync)((0, import_node_path18.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs19.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  if ((0, import_node_fs22.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs22.mkdirSync)((0, import_node_path18.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs22.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = (0, import_node_path18.join)(worktreePath, REPO_REVIEW_PATH);
@@ -8521,8 +8894,8 @@ function resolveReviewGuidelines(worktreePath) {
     };
   }
   ensureAttachmentsGitignore(worktreePath);
-  (0, import_node_fs19.mkdirSync)((0, import_node_path18.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs19.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs22.mkdirSync)((0, import_node_path18.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs22.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -8721,8 +9094,8 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 }
 
 // src/threads/adopt.ts
-var import_node_child_process = require("child_process");
-var import_node_fs20 = require("fs");
+var import_node_child_process2 = require("child_process");
+var import_node_fs23 = require("fs");
 var import_node_os8 = require("os");
 var import_node_path19 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
@@ -8747,21 +9120,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs20.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs23.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs20.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs23.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
     const agentsFile = (0, import_node_path19.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs20.existsSync)(agentsFile)) continue;
+    if (!(0, import_node_fs23.existsSync)(agentsFile)) continue;
     let text;
     try {
-      text = (0, import_node_fs20.readFileSync)(agentsFile, "utf8");
+      text = (0, import_node_fs23.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -8785,7 +9158,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs20.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs23.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -8809,18 +9182,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs23.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const tmp = (0, import_node_fs23.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
   const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs23.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs20.existsSync)(src)) {
+      if ((0, import_node_fs23.existsSync)(src)) {
         try {
-          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs23.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -8896,22 +9269,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs23.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs23.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const tmp = (0, import_node_fs23.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
   const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs23.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs20.existsSync)(src)) {
+      if ((0, import_node_fs23.existsSync)(src)) {
         try {
-          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs23.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -8929,7 +9302,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs20.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs23.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -8969,7 +9342,7 @@ function importConductorWorkspace(workspaceId) {
       }
       let repoPath = worktreePath;
       try {
-        repoPath = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+        repoPath = (0, import_node_child_process2.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
           cwd: worktreePath,
           encoding: "utf8"
         }).trim();
@@ -8992,7 +9365,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs23.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -9000,7 +9373,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-var import_node_fs21 = require("fs");
+var import_node_fs24 = require("fs");
 init_run();
 init_stack();
 init_worktree();
@@ -9068,7 +9441,7 @@ async function openStackLayer(input, _onSetupLine) {
   let createdWorktree = false;
   const trees = await listWorktrees(repoPath);
   const checkedOut = trees.find((w) => w.branch === branchName);
-  if (checkedOut?.path && (0, import_node_fs21.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs24.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -9210,7 +9583,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs21.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs24.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
   if (!input.branches.length) throw new Error("At least one branch name required");
   const status = await detectGhStack(repoPath);
   if (!status.available) throw new Error(status.reason);
@@ -9277,7 +9650,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs21.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs24.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -9292,12 +9665,12 @@ async function createPrStack(input, onSetupLine) {
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs22 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_path20 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs22.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs25.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -9305,7 +9678,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs22.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs25.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -9743,7 +10116,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
   const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs22.statSync)(abs);
+  const st = (0, import_node_fs25.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -9752,7 +10125,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs22.readFileSync)(abs);
+  const buf = (0, import_node_fs25.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -9763,11 +10136,11 @@ function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
   const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs22.statSync)(abs);
+  const st = (0, import_node_fs25.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs22.readFileSync)(abs);
+  const buf = (0, import_node_fs25.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -9811,8 +10184,8 @@ function assertSafeRelativePath(relativePath) {
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
   const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  (0, import_node_fs22.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
-  (0, import_node_fs22.writeFileSync)(abs, content, "utf8");
+  (0, import_node_fs25.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
+  (0, import_node_fs25.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -9991,7 +10364,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs23 = require("fs");
+var import_node_fs26 = require("fs");
 var import_node_os9 = require("os");
 var import_node_path21 = require("path");
 function toCommand(name) {
@@ -10025,7 +10398,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs23.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs26.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -10044,19 +10417,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs23.existsSync)(dir)) return;
+  if (!(0, import_node_fs26.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs23.readdirSync)(dir);
+    entries = (0, import_node_fs26.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
     const skillMd = (0, import_node_path21.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs23.existsSync)(skillMd)) continue;
+    if (!(0, import_node_fs26.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs23.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs26.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -10065,12 +10438,12 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs23.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs26.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs23.readdirSync)(dir);
+      entries = (0, import_node_fs26.readdirSync)(dir);
     } catch {
       return;
     }
@@ -10082,7 +10455,7 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       if (entry === "node_modules" || entry === ".git") continue;
       const full = (0, import_node_path21.join)(dir, entry);
       try {
-        if (!(0, import_node_fs23.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs26.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -10122,7 +10495,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = (0, import_node_fs23.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs26.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -10215,7 +10588,7 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs24 = require("fs");
+var import_node_fs27 = require("fs");
 var import_node_path22 = require("path");
 var import_node_crypto5 = require("crypto");
 init_workspace_scratch();
@@ -10253,21 +10626,21 @@ function imageMimeType(filePath) {
 }
 function ensureAttachmentsDir(worktreePath) {
   const dir = (0, import_node_path22.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs24.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs27.mkdirSync)(dir, { recursive: true });
   const gi = (0, import_node_path22.join)(dir, ".gitignore");
-  if (!(0, import_node_fs24.existsSync)(gi)) {
-    (0, import_node_fs24.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  if (!(0, import_node_fs27.existsSync)(gi)) {
+    (0, import_node_fs27.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs24.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
+  if (!(0, import_node_fs27.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
   const ext = (0, import_node_path22.extname)(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!(0, import_node_fs24.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs27.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
@@ -10325,13 +10698,13 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   for (const abs of absolutePaths) {
     const originalName = (0, import_node_path22.basename)(abs);
     try {
-      const st = (0, import_node_fs24.statSync)(abs);
+      const st = (0, import_node_fs27.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
       const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs24.copyFileSync)(abs, destAbs);
+      (0, import_node_fs27.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs24.readFileSync)(destAbs);
+      const buf = (0, import_node_fs27.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -10354,7 +10727,7 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
       const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs24.writeFileSync)(destAbs, buf);
+      (0, import_node_fs27.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -10383,9 +10756,9 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     const name = (0, import_node_path22.basename)(rel);
     try {
       const abs = (0, import_node_path22.join)(worktreePath, rel);
-      const st = (0, import_node_fs24.statSync)(abs);
+      const st = (0, import_node_fs27.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs24.readFileSync)(abs);
+      const buf = (0, import_node_fs27.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -10400,7 +10773,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-var import_node_fs25 = require("fs");
+var import_node_fs28 = require("fs");
 var import_node_path23 = require("path");
 init_worktree_labels();
 function normPath2(p) {
@@ -10500,6 +10873,9 @@ function formatWorktreeDirective(thread, opts) {
   );
   return lines.join("\n");
 }
+function formatWorktreeReminder() {
+  return "Sideboard worktree: stay in this cwd for all file and git work. Push and open PRs against origin, never upstream. Do not edit the main repo checkout.";
+}
 function formatArtifactDirective() {
   return [
     "Sideboard side column (desktop UI):",
@@ -10520,60 +10896,6 @@ function formatArtifactDirective() {
     "Never say artifacts, CMS UI, or the Files column are unavailable. Prefer present_schema for list/edit/publish; present_files for storage UI; html fences for standalone pages."
   ].join("\n");
 }
-var FILES_BY_AGENT = {
-  claude: [
-    "CLAUDE.md",
-    ".claude/CLAUDE.md",
-    "CLAUDE.local.md",
-    "AGENTS.md",
-    "AGENT.md"
-  ],
-  codex: ["AGENTS.md", "AGENT.md", ".codex/AGENTS.md", "CLAUDE.md"],
-  opencode: ["AGENTS.md", "AGENT.md", "OPENCODE.md", "CLAUDE.md"],
-  brightsy: ["AGENTS.md", "AGENT.md", "CLAUDE.md"],
-  cursor: ["AGENTS.md", "AGENT.md", ".cursor/rules", "CLAUDE.md"]
-};
-var MAX_CHARS_PER_FILE = 48e3;
-function loadAgentInstructions(worktreePath, agent) {
-  const candidates = FILES_BY_AGENT[agent] ?? FILES_BY_AGENT.claude;
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const rel of candidates) {
-    if (seen.has(rel)) continue;
-    const abs = (0, import_node_path23.join)(worktreePath, rel);
-    if (!(0, import_node_fs25.existsSync)(abs)) continue;
-    try {
-      if (!(0, import_node_fs25.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs25.readFileSync)(abs, "utf8");
-      if (!content.trim()) continue;
-      if (content.length > MAX_CHARS_PER_FILE) {
-        content = `${content.slice(0, MAX_CHARS_PER_FILE)}
-
-\u2026(truncated)`;
-      }
-      seen.add(rel);
-      out.push({ relativePath: rel, content });
-    } catch {
-    }
-  }
-  return out;
-}
-function formatAgentInstructions(files) {
-  if (files.length === 0) return null;
-  const parts = [
-    "Project agent instructions (from the worktree \u2014 follow these):",
-    ""
-  ];
-  for (const f of files) {
-    parts.push(`## ${f.relativePath}`);
-    parts.push("");
-    parts.push(f.content.trim());
-    parts.push("");
-    parts.push("---");
-    parts.push("");
-  }
-  return parts.join("\n").trimEnd();
-}
 
 // src/orchestrator/orchestrator.ts
 init_types();
@@ -10698,7 +11020,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs28.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs31.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -11115,13 +11437,14 @@ var Orchestrator = class {
       "Files column: MCP present_files (brightsy account storage or memory).",
       "Do not say artifacts/CMS UI are unavailable."
     ].join(" ") : null;
+    const worktreeReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatWorktreeReminder() : null;
     const agentPrompt = [
       thread.planMode ? PLAN_MODE_INSTRUCTION : null,
       orchestrationReminder,
+      worktreeReminder,
       artifactReminder,
       expandedPrompt
     ].filter(Boolean).join("\n\n");
-    const instructionFiles = loadAgentInstructions(thread.worktreePath, thread.agent);
     if (thread.attachments.length > 0) {
       updateThread(threadId, { attachments: [] });
     }
@@ -11149,7 +11472,6 @@ var Orchestrator = class {
     const renameBranchDirective = !isBrightsy && !isOrchestration && autoRenameBranchEnabled2() ? formatRenameBranchDirective(fresh, {
       customPrompt: settings?.prompts?.renameBranch
     }) : null;
-    const instructions = fresh.agent === "claude" || isBrightsy ? null : formatAgentInstructions(instructionFiles);
     let seed = null;
     if (!fresh.sessionId) {
       const prior = fresh.messages.slice(0, -1);
@@ -11170,12 +11492,12 @@ var Orchestrator = class {
         });
       }
     }
-    const cachedPrefix = [
+    const cachedPrefix = fresh.sessionId ? "" : [
       coordinatorDirective,
       worktreeDirective,
       artifactDirective,
       renameBranchDirective,
-      ...fresh.agent === "claude" && fresh.sessionId ? [] : [instructions, seed]
+      seed
     ].filter(Boolean).join("\n\n---\n\n");
     try {
       const stderrTail = [];
@@ -11262,15 +11584,11 @@ var Orchestrator = class {
         const retryThread = this.requireThread(threadId);
         const prior = retryThread.messages.slice(0, -1);
         const retrySeed = buildSessionSeed(prior);
-        const retryInstructions = retryThread.agent === "claude" ? null : formatAgentInstructions(
-          loadAgentInstructions(retryThread.worktreePath, retryThread.agent)
-        );
         const retryPrefix = [
           coordinatorDirective,
           worktreeDirective,
           artifactDirective,
           renameBranchDirective,
-          retryInstructions,
           retrySeed
         ].filter(Boolean).join("\n\n---\n\n");
         const retryHandle = await spawnAgentTurn(
@@ -12105,7 +12423,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!(0, import_node_fs28.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs31.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -12314,6 +12632,7 @@ function mcpArchiveBlockedReason(thread) {
 }
 
 // src/mcp/server.ts
+init_profile();
 var MAX_ORCH_THREADS = 5;
 var CREATE_THREAD_TIMEOUT_MS = 9e4;
 function withTimeout(promise, ms, label) {
@@ -12427,14 +12746,13 @@ async function startMcpServer() {
       ),
       artifact_id: import_zod.z.string().optional().describe("Stable id when updating the same artifact across turns")
     },
-    async ({ title, type, content, artifact_id }) => {
+    async ({ title, type, artifact_id }) => {
       const id = artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
       const payload = {
         ok: true,
         artifact_id: id,
         title,
         type,
-        content,
         message: "Artifact accepted. Sideboard desktop opens it in the side column beside chat."
       };
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
@@ -12487,7 +12805,6 @@ async function startMcpServer() {
         ok: true,
         path,
         title: title?.trim() || "Plan",
-        content,
         message: "Plan saved to .context/attachments/plan.md and shown in Sideboard chat for approval."
       };
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
@@ -12517,9 +12834,6 @@ async function startMcpServer() {
         datasource: args.datasource ?? (args.resource ? "inline" : "brightsy"),
         resource_id: args.resource_id,
         record_id: args.record_id,
-        resource: args.resource,
-        record: args.record,
-        records: args.records,
         message: "Schema pane accepted. Sideboard desktop opens the CMS column beside chat."
       };
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
@@ -12547,739 +12861,741 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
-  const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
-  const accountDefaults = resolveThreadDefaults2();
-  const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
-  server.tool(
-    "create_thread",
-    `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Then use send_to_thread to chat.`,
-    {
-      sourceType: import_zod.z.enum(["branch", "pr", "ticket"]),
-      sourceRef: import_zod.z.string(),
-      agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
-      model: import_zod.z.string().nullable().optional().describe(
-        `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
-      ),
-      repoPath: import_zod.z.string(),
-      title: import_zod.z.string().optional(),
-      parentThreadId: import_zod.z.string().optional().describe(
-        "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
-      )
-    },
-    async (args) => {
-      const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
-      let parentId = args.parentThreadId?.trim() || "";
-      let parent = parentId ? orch.getThread(parentId) : null;
-      let parentCorrectedFrom;
-      if (envParentId) {
-        const envParent = orch.getThread(envParentId);
-        if (envParent) {
-          if (parentId && parentId !== envParentId) parentCorrectedFrom = parentId;
-          else if (!parentId) parentCorrectedFrom = void 0;
-          parentId = envParentId;
-          parent = envParent;
+  if (sideboardMcpProfile() !== "worktree") {
+    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
+    const accountDefaults = resolveThreadDefaults2();
+    const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
+    server.tool(
+      "create_thread",
+      `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Then use send_to_thread to chat.`,
+      {
+        sourceType: import_zod.z.enum(["branch", "pr", "ticket"]),
+        sourceRef: import_zod.z.string(),
+        agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
+        model: import_zod.z.string().nullable().optional().describe(
+          `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
+        ),
+        repoPath: import_zod.z.string(),
+        title: import_zod.z.string().optional(),
+        parentThreadId: import_zod.z.string().optional().describe(
+          "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
+        )
+      },
+      async (args) => {
+        const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
+        let parentId = args.parentThreadId?.trim() || "";
+        let parent = parentId ? orch.getThread(parentId) : null;
+        let parentCorrectedFrom;
+        if (envParentId) {
+          const envParent = orch.getThread(envParentId);
+          if (envParent) {
+            if (parentId && parentId !== envParentId) parentCorrectedFrom = parentId;
+            else if (!parentId) parentCorrectedFrom = void 0;
+            parentId = envParentId;
+            parent = envParent;
+          }
         }
-      }
-      if (parentId && !parent) {
-        parentCorrectedFrom = parentId;
-        parentId = "";
-        parent = null;
-      }
-      if (parentId) {
-        const children = orch.getThreads(false).filter((t) => t.parentThreadId === parentId);
-        if (children.length >= MAX_ORCH_THREADS) {
+        if (parentId && !parent) {
+          parentCorrectedFrom = parentId;
+          parentId = "";
+          parent = null;
+        }
+        if (parentId) {
+          const children = orch.getThreads(false).filter((t) => t.parentThreadId === parentId);
+          if (children.length >= MAX_ORCH_THREADS) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+        let agentArg = args.agent;
+        let agentCoercedFrom;
+        const resolvedProbe = resolveNewThreadOptions2({ agent: agentArg }).agent;
+        if (resolvedProbe === "codex") {
+          agentCoercedFrom = agentArg ?? "codex";
+          const accountAgent = resolveNewThreadOptions2({}).agent;
+          agentArg = accountAgent !== "codex" ? accountAgent : "cursor";
+        }
+        const opts = resolveNewThreadOptions2({
+          agent: agentArg,
+          model: args.model
+        });
+        try {
+          const thread = await withTimeout(
+            orch.createThread({
+              sourceType: args.sourceType,
+              sourceRef: args.sourceRef,
+              agent: opts.agent,
+              model: opts.model,
+              effort: opts.effort,
+              fast: opts.fast,
+              repoPath: args.repoPath,
+              title: args.title,
+              parentThreadId: parentId || null
+            }),
+            CREATE_THREAD_TIMEOUT_MS,
+            "create_thread"
+          );
+          const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
           return {
             content: [
               {
                 type: "text",
-                text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
+                text: JSON.stringify({
+                  id: thread.id,
+                  title: thread.title,
+                  branchName: thread.branchName,
+                  worktreePath: thread.worktreePath,
+                  agent: thread.agent,
+                  model: thread.model,
+                  status: thread.status,
+                  link: `sideboard://thread/${thread.id}`,
+                  parentThreadId: thread.parentThreadId,
+                  ...agentCoercedFrom ? {
+                    agentCoercedFrom,
+                    note: `Avoid nested Codex under a Codex orchestrator \u2014 used Account default agent=${thread.agent}`
+                  } : {},
+                  ...parentCorrectedFrom ? { parentCorrectedFrom, parentNote } : {}
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `create_thread failed: ${message}`
               }
             ],
             isError: true
           };
         }
       }
-      let agentArg = args.agent;
-      let agentCoercedFrom;
-      const resolvedProbe = resolveNewThreadOptions2({ agent: agentArg }).agent;
-      if (resolvedProbe === "codex") {
-        agentCoercedFrom = agentArg ?? "codex";
-        const accountAgent = resolveNewThreadOptions2({}).agent;
-        agentArg = accountAgent !== "codex" ? accountAgent : "cursor";
-      }
-      const opts = resolveNewThreadOptions2({
-        agent: agentArg,
-        model: args.model
-      });
-      try {
-        const thread = await withTimeout(
-          orch.createThread({
-            sourceType: args.sourceType,
-            sourceRef: args.sourceRef,
-            agent: opts.agent,
-            model: opts.model,
-            effort: opts.effort,
-            fast: opts.fast,
-            repoPath: args.repoPath,
-            title: args.title,
-            parentThreadId: parentId || null
-          }),
-          CREATE_THREAD_TIMEOUT_MS,
-          "create_thread"
-        );
-        const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
+    );
+    server.tool(
+      "send_to_thread",
+      "Queue a prompt on a worktree thread chat (runs under concurrency cap). Use after create_thread to start or continue a conversation. Set force_stop=true to interrupt an in-flight/queued turn (kill + clear queue) before queueing this prompt \u2014 use when the thread is mid-turn or has stale queued prompts you need to replace.",
+      {
+        ref: import_zod.z.string(),
+        prompt: import_zod.z.string(),
+        force_stop: import_zod.z.boolean().optional()
+      },
+      async ({ ref, prompt, force_stop }) => {
+        if (force_stop) {
+          const existing = orch.getThread(ref);
+          if (existing) {
+            orch.stop(ref, { clearQueue: true });
+          }
+        }
+        const thread = await orch.send(ref, prompt);
         return {
           content: [
             {
               type: "text",
               text: JSON.stringify({
                 id: thread.id,
-                title: thread.title,
-                branchName: thread.branchName,
-                worktreePath: thread.worktreePath,
-                agent: thread.agent,
-                model: thread.model,
                 status: thread.status,
-                link: `sideboard://thread/${thread.id}`,
-                parentThreadId: thread.parentThreadId,
-                ...agentCoercedFrom ? {
-                  agentCoercedFrom,
-                  note: `Avoid nested Codex under a Codex orchestrator \u2014 used Account default agent=${thread.agent}`
-                } : {},
-                ...parentCorrectedFrom ? { parentCorrectedFrom, parentNote } : {}
+                queueLength: thread.queue.length,
+                forceStopped: Boolean(force_stop)
               })
             }
           ]
         };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+      }
+    );
+    server.tool(
+      "wait_for_turn",
+      "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread to read the agent reply.",
+      {
+        ref: import_zod.z.string(),
+        timeoutMs: import_zod.z.number().optional()
+      },
+      async ({ ref, timeoutMs }) => {
+        const thread = await orch.waitForTurn(ref, timeoutMs ?? 6e5);
+        const result = orch.getTurnResult(thread.id);
         return {
           content: [
             {
               type: "text",
-              text: `create_thread failed: ${message}`
+              text: JSON.stringify({
+                id: thread.id,
+                status: result.status,
+                text: result.text
+              })
             }
-          ],
-          isError: true
+          ]
         };
       }
-    }
-  );
-  server.tool(
-    "send_to_thread",
-    "Queue a prompt on a worktree thread chat (runs under concurrency cap). Use after create_thread to start or continue a conversation. Set force_stop=true to interrupt an in-flight/queued turn (kill + clear queue) before queueing this prompt \u2014 use when the thread is mid-turn or has stale queued prompts you need to replace.",
-    {
-      ref: import_zod.z.string(),
-      prompt: import_zod.z.string(),
-      force_stop: import_zod.z.boolean().optional()
-    },
-    async ({ ref, prompt, force_stop }) => {
-      if (force_stop) {
-        const existing = orch.getThread(ref);
-        if (existing) {
-          orch.stop(ref, { clearQueue: true });
-        }
+    );
+    server.tool(
+      "get_turn_result",
+      "Final assistant message only (not full transcript)",
+      { ref: import_zod.z.string() },
+      async ({ ref }) => {
+        const result = orch.getTurnResult(ref);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
       }
-      const thread = await orch.send(ref, prompt);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              id: thread.id,
-              status: thread.status,
-              queueLength: thread.queue.length,
-              forceStopped: Boolean(force_stop)
-            })
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "wait_for_turn",
-    "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread to read the agent reply.",
-    {
-      ref: import_zod.z.string(),
-      timeoutMs: import_zod.z.number().optional()
-    },
-    async ({ ref, timeoutMs }) => {
-      const thread = await orch.waitForTurn(ref, timeoutMs ?? 6e5);
-      const result = orch.getTurnResult(thread.id);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              id: thread.id,
-              status: result.status,
-              text: result.text
-            })
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "get_turn_result",
-    "Final assistant message only (not full transcript)",
-    { ref: import_zod.z.string() },
-    async ({ ref }) => {
-      const result = orch.getTurnResult(ref);
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
-    }
-  );
-  server.tool(
-    "stop_thread",
-    "Force-stop a thread: kill any in-flight agent turn AND clear queued prompts so drainQueue cannot continue. Does not archive the worktree. Optional force defaults to true.",
-    {
-      ref: import_zod.z.string(),
-      force: import_zod.z.boolean().optional()
-    },
-    async ({ ref, force }) => {
-      const t = orch.getThread(ref);
-      if (!t) {
+    );
+    server.tool(
+      "stop_thread",
+      "Force-stop a thread: kill any in-flight agent turn AND clear queued prompts so drainQueue cannot continue. Does not archive the worktree. Optional force defaults to true.",
+      {
+        ref: import_zod.z.string(),
+        force: import_zod.z.boolean().optional()
+      },
+      async ({ ref, force }) => {
+        const t = orch.getThread(ref);
+        if (!t) {
+          return {
+            content: [{ type: "text", text: `Thread not found: ${ref}` }],
+            isError: true
+          };
+        }
+        const clearQueue = force !== false;
+        const hadQueued = t.queue.length > 0;
+        const stopped = orch.stop(ref, { clearQueue });
         return {
-          content: [{ type: "text", text: `Thread not found: ${ref}` }],
-          isError: true
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: stopped.id,
+                status: stopped.status,
+                clearedQueue: clearQueue && hadQueued
+              })
+            }
+          ]
         };
       }
-      const clearQueue = force !== false;
-      const hadQueued = t.queue.length > 0;
-      const stopped = orch.stop(ref, { clearQueue });
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              id: stopped.id,
-              status: stopped.status,
-              clearedQueue: clearQueue && hadQueued
-            })
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "archive_thread",
-    "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Cannot archive the cloud coordinator \u2014 use the Sideboard UI for that.",
-    { ref: import_zod.z.string() },
-    async ({ ref }) => {
-      const t = orch.getThread(ref);
-      if (!t) {
+    );
+    server.tool(
+      "archive_thread",
+      "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Cannot archive the cloud coordinator \u2014 use the Sideboard UI for that.",
+      { ref: import_zod.z.string() },
+      async ({ ref }) => {
+        const t = orch.getThread(ref);
+        if (!t) {
+          return {
+            content: [{ type: "text", text: `Thread not found: ${ref}` }],
+            isError: true
+          };
+        }
+        const blocked = mcpArchiveBlockedReason(t);
+        if (blocked) {
+          return {
+            content: [{ type: "text", text: blocked }],
+            isError: true
+          };
+        }
+        const archived = await orch.archive(ref);
         return {
-          content: [{ type: "text", text: `Thread not found: ${ref}` }],
-          isError: true
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: archived.id,
+                status: archived.status
+              })
+            }
+          ]
         };
       }
-      const blocked = mcpArchiveBlockedReason(t);
-      if (blocked) {
-        return {
-          content: [{ type: "text", text: blocked }],
-          isError: true
-        };
+    );
+    server.tool(
+      "restore_thread",
+      "Restore an archived thread (recreates worktree from branch when needed)",
+      { ref: import_zod.z.string() },
+      async ({ ref }) => {
+        try {
+          const restored = await orch.restore(ref);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  id: restored.id,
+                  status: restored.status,
+                  worktreePath: restored.worktreePath
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: message }], isError: true };
+        }
       }
-      const archived = await orch.archive(ref);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              id: archived.id,
-              status: archived.status
-            })
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "restore_thread",
-    "Restore an archived thread (recreates worktree from branch when needed)",
-    { ref: import_zod.z.string() },
-    async ({ ref }) => {
-      try {
-        const restored = await orch.restore(ref);
+    );
+    server.tool(
+      "get_diff",
+      "Compact diff summary (capped hunks, paginated)",
+      {
+        ref: import_zod.z.string(),
+        maxFiles: import_zod.z.number().optional()
+      },
+      async ({ ref, maxFiles }) => {
+        const summary = await orch.diffSummary(ref);
         return {
           content: [
             {
               type: "text",
               text: JSON.stringify({
-                id: restored.id,
-                status: restored.status,
-                worktreePath: restored.worktreePath
+                ...summary,
+                files: summary.files.slice(0, maxFiles ?? 10)
               })
             }
           ]
         };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: message }], isError: true };
       }
-    }
-  );
-  server.tool(
-    "get_diff",
-    "Compact diff summary (capped hunks, paginated)",
-    {
-      ref: import_zod.z.string(),
-      maxFiles: import_zod.z.number().optional()
-    },
-    async ({ ref, maxFiles }) => {
-      const summary = await orch.diffSummary(ref);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              ...summary,
-              files: summary.files.slice(0, maxFiles ?? 10)
-            })
+    );
+    server.tool(
+      "request_review",
+      'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.',
+      { ref: import_zod.z.string().describe("Worktree thread id/ref to review") },
+      async ({ ref }) => {
+        try {
+          const tab = await orch.requestReview(ref);
+          const from = orch.getThread(ref);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  id: tab.id,
+                  title: tab.title,
+                  status: tab.status,
+                  fromThreadId: from?.id ?? ref,
+                  link: `sideboard://thread/${tab.id}`
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: message }], isError: true };
+        }
+      }
+    );
+    const agentEnum = import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+    server.tool(
+      "list_models",
+      "List models for an agent. Prefer Auto: do not call this unless you have a reason to pin a specific model (user request, cost/latency, capability). Omit agent to list all.",
+      {
+        agent: agentEnum.optional().describe("Limit to one agent; omit for all")
+      },
+      async ({ agent }) => {
+        try {
+          const catalogs = await listModelsForAgent(agent);
+          return {
+            content: [{ type: "text", text: JSON.stringify(catalogs, null, 2) }]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: message }], isError: true };
+        }
+      }
+    );
+    server.tool(
+      "fork_worktree",
+      "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn on the returned id.",
+      {
+        ref: import_zod.z.string().describe("Worktree thread id/ref to fork"),
+        through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
+        model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod.z.string().optional()
+      },
+      async ({ ref, through_index, agent, model, title }) => {
+        try {
+          const source = orch.getThread(ref);
+          if (source) await orch.reconcile(source.repoPath, { drainQueues: false });
+          const thread = await orch.forkThreadWorktree({
+            threadId: ref,
+            throughIndex: through_index,
+            agent,
+            model,
+            title
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  id: thread.id,
+                  title: thread.title,
+                  status: thread.status,
+                  agent: thread.agent,
+                  model: thread.model,
+                  branchName: thread.branchName,
+                  worktreePath: thread.worktreePath,
+                  fromThreadId: source?.id ?? ref,
+                  link: `sideboard://thread/${thread.id}`
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: message }], isError: true };
+        }
+      }
+    );
+    server.tool(
+      "fork_chat",
+      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Remote coordinators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
+      {
+        ref: import_zod.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
+        model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod.z.string().optional()
+      },
+      async ({ ref, through_index, agent, model, title }) => {
+        try {
+          const source = orch.getThread(ref);
+          if (!source) {
+            return {
+              content: [{ type: "text", text: `Thread not found: ${ref}` }],
+              isError: true
+            };
           }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "request_review",
-    'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.',
-    { ref: import_zod.z.string().describe("Worktree thread id/ref to review") },
-    async ({ ref }) => {
-      try {
-        const tab = await orch.requestReview(ref);
-        const from = orch.getThread(ref);
+          const tab = orch.forkChatTab({
+            threadId: source.id,
+            throughIndex: through_index,
+            agent,
+            model,
+            title
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  id: tab.id,
+                  title: tab.title,
+                  status: tab.status,
+                  agent: tab.agent,
+                  model: tab.model,
+                  sourceType: tab.sourceType,
+                  worktreePath: tab.worktreePath,
+                  fromThreadId: source.id,
+                  link: `sideboard://thread/${tab.id}`
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: message }], isError: true };
+        }
+      }
+    );
+    server.tool(
+      "run_dev_script",
+      "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",
+      {
+        ref: import_zod.z.string(),
+        name: import_zod.z.string().optional()
+      },
+      async ({ ref, name }) => {
+        const result = await orch.startDev(ref, name);
         return {
           content: [
             {
               type: "text",
               text: JSON.stringify({
-                id: tab.id,
-                title: tab.title,
-                status: tab.status,
-                fromThreadId: from?.id ?? ref,
-                link: `sideboard://thread/${tab.id}`
+                port: result.port,
+                scriptName: result.scriptName,
+                ports: result.ports,
+                url: `http://localhost:${result.port}`
               })
             }
           ]
         };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: message }], isError: true };
       }
-    }
-  );
-  const agentEnum = import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
-  server.tool(
-    "list_models",
-    "List models for an agent. Prefer Auto: do not call this unless you have a reason to pin a specific model (user request, cost/latency, capability). Omit agent to list all.",
-    {
-      agent: agentEnum.optional().describe("Limit to one agent; omit for all")
-    },
-    async ({ agent }) => {
-      try {
-        const catalogs = await listModelsForAgent(agent);
+    );
+    server.tool(
+      "list_run_scripts",
+      "List named run scripts available for a thread",
+      { ref: import_zod.z.string() },
+      async ({ ref }) => {
+        const scripts = orch.listThreadRunScripts(ref);
+        const active = orch.getActiveRuns(ref);
         return {
-          content: [{ type: "text", text: JSON.stringify(catalogs, null, 2) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ scripts, active }, null, 2)
+            }
+          ]
         };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: message }], isError: true };
       }
-    }
-  );
-  server.tool(
-    "fork_worktree",
-    "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn on the returned id.",
-    {
-      ref: import_zod.z.string().describe("Worktree thread id/ref to fork"),
-      through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
-      agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-      model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-      title: import_zod.z.string().optional()
-    },
-    async ({ ref, through_index, agent, model, title }) => {
-      try {
-        const source = orch.getThread(ref);
-        if (source) await orch.reconcile(source.repoPath, { drainQueues: false });
-        const thread = await orch.forkThreadWorktree({
-          threadId: ref,
-          throughIndex: through_index,
-          agent,
-          model,
-          title
+    );
+    server.tool(
+      "stop_dev_script",
+      "Stop a running script for a thread (all scripts if name omitted)",
+      {
+        ref: import_zod.z.string(),
+        name: import_zod.z.string().optional()
+      },
+      async ({ ref, name }) => {
+        orch.stopDev(ref, name);
+        return { content: [{ type: "text", text: "ok" }] };
+      }
+    );
+    server.tool(
+      "run_setup",
+      "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
+      { ref: import_zod.z.string() },
+      async ({ ref }) => {
+        const result = await orch.runSetup(ref);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }]
+        };
+      }
+    );
+    server.tool(
+      "add_workspace",
+      "Register a git repo as a Sideboard workspace",
+      { repoPath: import_zod.z.string() },
+      async ({ repoPath }) => {
+        const ws = await orch.addWorkspace(repoPath);
+        return { content: [{ type: "text", text: JSON.stringify(ws) }] };
+      }
+    );
+    server.tool(
+      "remove_workspace",
+      "Unregister a Sideboard workspace (does not archive threads)",
+      { repoPath: import_zod.z.string() },
+      async ({ repoPath }) => {
+        orch.removeWorkspace(repoPath);
+        return { content: [{ type: "text", text: "ok" }] };
+      }
+    );
+    server.tool(
+      "fanout",
+      "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
+      {
+        prompt: import_zod.z.string(),
+        agents: import_zod.z.array(import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: import_zod.z.string(),
+        sourceType: import_zod.z.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: import_zod.z.string().optional(),
+        title: import_zod.z.string().optional()
+      },
+      async (args) => {
+        const threads = await orch.bestOfN(args);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                threads.map((t) => ({
+                  id: t.id,
+                  agent: t.agent,
+                  branchName: t.branchName,
+                  worktreePath: t.worktreePath
+                })),
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "list_branches",
+      "List git branches in a registered workspace. Pass repoPath from list_workspaces (unmerged into the default branch by default \u2014 for create_thread sourceType=branch).",
+      {
+        repoPath: import_zod.z.string(),
+        unmergedOnly: import_zod.z.boolean().optional()
+      },
+      async ({ repoPath, unmergedOnly }) => {
+        const root = await resolveRepoRoot(repoPath);
+        const branches = await listBranches(root, {
+          unmergedOnly: unmergedOnly !== false
         });
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify({
-                id: thread.id,
-                title: thread.title,
-                status: thread.status,
-                agent: thread.agent,
-                model: thread.model,
-                branchName: thread.branchName,
-                worktreePath: thread.worktreePath,
-                fromThreadId: source?.id ?? ref,
-                link: `sideboard://thread/${thread.id}`
-              })
+              text: branches.map((b) => `${b.current ? "*" : " "} ${b.name}`).join("\n")
             }
           ]
         };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: message }], isError: true };
       }
-    }
-  );
-  server.tool(
-    "fork_chat",
-    "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Remote coordinators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
-    {
-      ref: import_zod.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-      through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
-      agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-      model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-      title: import_zod.z.string().optional()
-    },
-    async ({ ref, through_index, agent, model, title }) => {
-      try {
-        const source = orch.getThread(ref);
-        if (!source) {
-          return {
-            content: [{ type: "text", text: `Thread not found: ${ref}` }],
-            isError: true
-          };
-        }
-        const tab = orch.forkChatTab({
-          threadId: source.id,
-          throughIndex: through_index,
-          agent,
-          model,
-          title
+    );
+    server.tool(
+      "list_prs",
+      "List open GitHub PRs for a registered workspace. Pass repoPath from list_workspaces (uses gh against that repo remote). Then create_thread with sourceType=pr.",
+      { repoPath: import_zod.z.string() },
+      async ({ repoPath }) => {
+        const root = await resolveRepoRoot(repoPath);
+        const prs = await listPrs(root);
+        return {
+          content: [
+            {
+              type: "text",
+              text: prs.map(
+                (p) => `#${p.number} ${p.title} (${p.headRefName})${p.isCrossRepository ? " [fork]" : ""}`
+              ).join("\n")
+            }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "get_pr_stack",
+      "Load the GitHub PR stack for a thread worktree (`gh stack view --json`). Returns null JSON when the branch is not stacked. Prefer this before mergePr on stacked PRs.",
+      { ref: import_zod.z.string() },
+      async ({ ref }) => {
+        const stack = await orch.getPrStack(ref);
+        return {
+          content: [{ type: "text", text: JSON.stringify(stack, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "open_pr_stack_layers",
+      "Materialize one worktree+thread per stack layer (or a single 1-based layer). Pass a thread ref already on the stack.",
+      {
+        ref: import_zod.z.string(),
+        layer: import_zod.z.number().int().positive().optional()
+      },
+      async ({ ref, layer }) => {
+        const result = await orch.openPrStackLayers(ref, { layer });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  stackNumber: result.stack.stackNumber,
+                  trunk: result.stack.trunk,
+                  threads: result.threads.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    branchName: t.branchName,
+                    stackLayer: t.stackLayer,
+                    worktreePath: t.worktreePath,
+                    prUrl: t.prUrl,
+                    link: `sideboard://thread/${t.id}`
+                  }))
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "add_stack_layer",
+      "Add a branch on top of the current stack (`gh stack add`) and open a worktree+thread for it.",
+      {
+        ref: import_zod.z.string(),
+        branchName: import_zod.z.string(),
+        title: import_zod.z.string().optional()
+      },
+      async ({ ref, branchName, title }) => {
+        const result = await orch.addStackLayer(ref, branchName, { title });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  id: result.thread.id,
+                  title: result.thread.title,
+                  branchName: result.thread.branchName,
+                  stackLayer: result.thread.stackLayer,
+                  worktreePath: result.thread.worktreePath,
+                  link: `sideboard://thread/${result.thread.id}`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "create_pr_stack",
+      "Create a new GitHub PR stack with one Sideboard worktree per layer (bottom\u2192top branch names). Requires `gh extension install github/gh-stack`.",
+      {
+        repoPath: import_zod.z.string(),
+        branches: import_zod.z.array(import_zod.z.string()).min(1),
+        agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: import_zod.z.string().optional(),
+        title: import_zod.z.string().optional()
+      },
+      async (args) => {
+        const result = await orch.createPrStack({
+          repoPath: args.repoPath,
+          branches: args.branches,
+          agent: args.agent,
+          base: args.base,
+          title: args.title
         });
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify({
-                id: tab.id,
-                title: tab.title,
-                status: tab.status,
-                agent: tab.agent,
-                model: tab.model,
-                sourceType: tab.sourceType,
-                worktreePath: tab.worktreePath,
-                fromThreadId: source.id,
-                link: `sideboard://thread/${tab.id}`
-              })
+              text: JSON.stringify(
+                {
+                  stackNumber: result.stack.stackNumber,
+                  trunk: result.stack.trunk,
+                  threads: result.threads.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    branchName: t.branchName,
+                    stackLayer: t.stackLayer,
+                    worktreePath: t.worktreePath,
+                    link: `sideboard://thread/${t.id}`
+                  }))
+                },
+                null,
+                2
+              )
             }
           ]
         };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: message }], isError: true };
       }
-    }
-  );
-  server.tool(
-    "run_dev_script",
-    "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",
-    {
-      ref: import_zod.z.string(),
-      name: import_zod.z.string().optional()
-    },
-    async ({ ref, name }) => {
-      const result = await orch.startDev(ref, name);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              port: result.port,
-              scriptName: result.scriptName,
-              ports: result.ports,
-              url: `http://localhost:${result.port}`
-            })
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "list_run_scripts",
-    "List named run scripts available for a thread",
-    { ref: import_zod.z.string() },
-    async ({ ref }) => {
-      const scripts = orch.listThreadRunScripts(ref);
-      const active = orch.getActiveRuns(ref);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ scripts, active }, null, 2)
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "stop_dev_script",
-    "Stop a running script for a thread (all scripts if name omitted)",
-    {
-      ref: import_zod.z.string(),
-      name: import_zod.z.string().optional()
-    },
-    async ({ ref, name }) => {
-      orch.stopDev(ref, name);
-      return { content: [{ type: "text", text: "ok" }] };
-    }
-  );
-  server.tool(
-    "run_setup",
-    "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
-    { ref: import_zod.z.string() },
-    async ({ ref }) => {
-      const result = await orch.runSetup(ref);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }]
-      };
-    }
-  );
-  server.tool(
-    "add_workspace",
-    "Register a git repo as a Sideboard workspace",
-    { repoPath: import_zod.z.string() },
-    async ({ repoPath }) => {
-      const ws = await orch.addWorkspace(repoPath);
-      return { content: [{ type: "text", text: JSON.stringify(ws) }] };
-    }
-  );
-  server.tool(
-    "remove_workspace",
-    "Unregister a Sideboard workspace (does not archive threads)",
-    { repoPath: import_zod.z.string() },
-    async ({ repoPath }) => {
-      orch.removeWorkspace(repoPath);
-      return { content: [{ type: "text", text: "ok" }] };
-    }
-  );
-  server.tool(
-    "fanout",
-    "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
-    {
-      prompt: import_zod.z.string(),
-      agents: import_zod.z.array(import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-      repoPath: import_zod.z.string(),
-      sourceType: import_zod.z.enum(["branch", "pr", "ticket"]).optional(),
-      sourceRef: import_zod.z.string().optional(),
-      title: import_zod.z.string().optional()
-    },
-    async (args) => {
-      const threads = await orch.bestOfN(args);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              threads.map((t) => ({
-                id: t.id,
-                agent: t.agent,
-                branchName: t.branchName,
-                worktreePath: t.worktreePath
-              })),
-              null,
-              2
-            )
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "list_branches",
-    "List git branches in a registered workspace. Pass repoPath from list_workspaces (unmerged into the default branch by default \u2014 for create_thread sourceType=branch).",
-    {
-      repoPath: import_zod.z.string(),
-      unmergedOnly: import_zod.z.boolean().optional()
-    },
-    async ({ repoPath, unmergedOnly }) => {
-      const root = await resolveRepoRoot(repoPath);
-      const branches = await listBranches(root, {
-        unmergedOnly: unmergedOnly !== false
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: branches.map((b) => `${b.current ? "*" : " "} ${b.name}`).join("\n")
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "list_prs",
-    "List open GitHub PRs for a registered workspace. Pass repoPath from list_workspaces (uses gh against that repo remote). Then create_thread with sourceType=pr.",
-    { repoPath: import_zod.z.string() },
-    async ({ repoPath }) => {
-      const root = await resolveRepoRoot(repoPath);
-      const prs = await listPrs(root);
-      return {
-        content: [
-          {
-            type: "text",
-            text: prs.map(
-              (p) => `#${p.number} ${p.title} (${p.headRefName})${p.isCrossRepository ? " [fork]" : ""}`
-            ).join("\n")
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "get_pr_stack",
-    "Load the GitHub PR stack for a thread worktree (`gh stack view --json`). Returns null JSON when the branch is not stacked. Prefer this before mergePr on stacked PRs.",
-    { ref: import_zod.z.string() },
-    async ({ ref }) => {
-      const stack = await orch.getPrStack(ref);
-      return {
-        content: [{ type: "text", text: JSON.stringify(stack, null, 2) }]
-      };
-    }
-  );
-  server.tool(
-    "open_pr_stack_layers",
-    "Materialize one worktree+thread per stack layer (or a single 1-based layer). Pass a thread ref already on the stack.",
-    {
-      ref: import_zod.z.string(),
-      layer: import_zod.z.number().int().positive().optional()
-    },
-    async ({ ref, layer }) => {
-      const result = await orch.openPrStackLayers(ref, { layer });
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                stackNumber: result.stack.stackNumber,
-                trunk: result.stack.trunk,
-                threads: result.threads.map((t) => ({
-                  id: t.id,
-                  title: t.title,
-                  branchName: t.branchName,
-                  stackLayer: t.stackLayer,
-                  worktreePath: t.worktreePath,
-                  prUrl: t.prUrl,
-                  link: `sideboard://thread/${t.id}`
-                }))
-              },
-              null,
-              2
-            )
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "add_stack_layer",
-    "Add a branch on top of the current stack (`gh stack add`) and open a worktree+thread for it.",
-    {
-      ref: import_zod.z.string(),
-      branchName: import_zod.z.string(),
-      title: import_zod.z.string().optional()
-    },
-    async ({ ref, branchName, title }) => {
-      const result = await orch.addStackLayer(ref, branchName, { title });
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                id: result.thread.id,
-                title: result.thread.title,
-                branchName: result.thread.branchName,
-                stackLayer: result.thread.stackLayer,
-                worktreePath: result.thread.worktreePath,
-                link: `sideboard://thread/${result.thread.id}`
-              },
-              null,
-              2
-            )
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "create_pr_stack",
-    "Create a new GitHub PR stack with one Sideboard worktree per layer (bottom\u2192top branch names). Requires `gh extension install github/gh-stack`.",
-    {
-      repoPath: import_zod.z.string(),
-      branches: import_zod.z.array(import_zod.z.string()).min(1),
-      agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-      base: import_zod.z.string().optional(),
-      title: import_zod.z.string().optional()
-    },
-    async (args) => {
-      const result = await orch.createPrStack({
-        repoPath: args.repoPath,
-        branches: args.branches,
-        agent: args.agent,
-        base: args.base,
-        title: args.title
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                stackNumber: result.stack.stackNumber,
-                trunk: result.stack.trunk,
-                threads: result.threads.map((t) => ({
-                  id: t.id,
-                  title: t.title,
-                  branchName: t.branchName,
-                  stackLayer: t.stackLayer,
-                  worktreePath: t.worktreePath,
-                  link: `sideboard://thread/${t.id}`
-                }))
-              },
-              null,
-              2
-            )
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "list_issues",
-    "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",
-    { repoPath: import_zod.z.string() },
-    async ({ repoPath }) => {
-      const root = await resolveRepoRoot(repoPath);
-      const result = await listIssues(root);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-    }
-  );
-  server.tool(
-    "list_linear_issues",
-    "Deprecated: prefer list_issues. Lists assigned Linear issues via the chosen agent MCP connector",
-    {
-      agent: import_zod.z.enum(["claude", "codex", "opencode"]),
-      repoPath: import_zod.z.string()
-    },
-    async ({ agent, repoPath }) => {
-      const issues = await listLinearIssues(agent, repoPath);
-      return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
-    }
-  );
+    );
+    server.tool(
+      "list_issues",
+      "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",
+      { repoPath: import_zod.z.string() },
+      async ({ repoPath }) => {
+        const root = await resolveRepoRoot(repoPath);
+        const result = await listIssues(root);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.tool(
+      "list_linear_issues",
+      "Deprecated: prefer list_issues. Lists assigned Linear issues via the chosen agent MCP connector",
+      {
+        agent: import_zod.z.enum(["claude", "codex", "opencode"]),
+        repoPath: import_zod.z.string()
+      },
+      async ({ agent, repoPath }) => {
+        const issues = await listLinearIssues(agent, repoPath);
+        return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
+      }
+    );
+  }
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);
 }