@sideboard-ai/core 0.1.62 → 0.1.66

package/dist/index.js

@@ -4,33 +4,14 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-46KMKHSD.js";
-import {
-  CLOUD_COORDINATOR_BUSY_REPLY,
-  CLOUD_COORDINATOR_STOPPED_REPLY,
-  CLOUD_COORDINATOR_TIMEOUT_REPLY,
-  CLOUD_ORCHESTRATOR_GOAL,
-  GLOBAL_WORKSPACE_ID,
-  SIDEBOARD_FORCE_STOP,
-  createGlobalChat,
-  ensureCloudCoordinator,
-  healOrchestrationSoccerTitles,
-  isCloudCoordinatorThread,
-  isGlobalRepoPath,
-  isGlobalThread,
-  isOrchestratorThread,
-  listGlobalThreads,
-  orchestrationTitleNeedsSoccerNickname,
-  orchestratorSessionPoisonedByBuiltins,
-  parseForceStopMessage,
-  takenTeamSlugsForOrchestration
-} from "./chunk-DXTGDXO2.js";
+} from "./chunk-PESJDZTB.js";
 import {
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
   MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
   PLAN_MODE_INSTRUCTION,
   SIDEBOARD_MCP_ALLOWED_TOOLS,
+  SIDEBOARD_MCP_PROFILE_ENV,
   allAdapters,
   brightsyAdapter,
   brightsyMcpAllowedTools,
@@ -41,6 +22,7 @@ import {
   countCacheControlBlocks,
   cursorAdapter,
   decodeBrightsyTarget,
+  dropCachedPrefixOnResume,
   encodeBrightsyTarget,
   findInvalidCacheControlTtlOrder,
   flattenTurnInput,
@@ -66,17 +48,41 @@ import {
   parseMcpList,
   parseSessionQuotaResetAt,
   permissionMode,
+  prepareTerminalCommand,
+  promptMentionsBrightsy,
   resolveCursorModelId,
+  resolveLoginCommand,
   resolveQuotaFallbackAgent,
   sanitizeMcpServerName,
+  shouldInjectBrightsyMcp,
+  sideboardMcpProfile,
+  threadRequestsBrightsyMcp,
   writeInjectedMcpConfig
-} from "./chunk-ZF5YJCXO.js";
+} from "./chunk-IFAU2DEY.js";
 import {
+  CLOUD_COORDINATOR_BUSY_REPLY,
+  CLOUD_COORDINATOR_STOPPED_REPLY,
+  CLOUD_COORDINATOR_TIMEOUT_REPLY,
+  CLOUD_ORCHESTRATOR_GOAL,
+  GLOBAL_WORKSPACE_ID,
   ORCHESTRATOR_AGENT_KINDS,
+  SIDEBOARD_FORCE_STOP,
   assertOrchestratorCapableAgent,
   coerceOrchestratorAgent,
-  isOrchestratorCapableAgent
-} from "./chunk-GI7E5733.js";
+  createGlobalChat,
+  ensureCloudCoordinator,
+  healOrchestrationSoccerTitles,
+  isCloudCoordinatorThread,
+  isGlobalRepoPath,
+  isGlobalThread,
+  isOrchestratorCapableAgent,
+  isOrchestratorThread,
+  listGlobalThreads,
+  orchestrationTitleNeedsSoccerNickname,
+  orchestratorSessionPoisonedByBuiltins,
+  parseForceStopMessage,
+  takenTeamSlugsForOrchestration
+} from "./chunk-YTNLOJPK.js";
 import {
   brightsyConfigPath,
   brightsyMcpServerName,
@@ -88,7 +94,7 @@ import {
   loadBrightsyConfig,
   saveBrightsyConfig,
   switchBrightsyAccount
-} from "./chunk-MBAL5FE6.js";
+} from "./chunk-DZYMNW2A.js";
 import {
   LEGACY_PLAN_FILE_REL,
   PLAN_FILE_NAME,
@@ -118,7 +124,7 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-27MAWNKY.js";
+} from "./chunk-AKPEXIKK.js";
 import {
   HARNESS_ENV_KEYS,
   appSettingsPath,
@@ -129,6 +135,7 @@ import {
   autoRunAfterSetupEnabled,
   brightsyCloudConnectAgent,
   brightsyCloudConnectEnabled,
+  brightsyInjectWorktreeMcpEnabled,
   caffeinateWhileCloudConnectEnabled,
   caffeinateWhileRunningEnabled,
   childEnvWithAppSettings,
@@ -147,18 +154,22 @@ import {
   maxConcurrentAgents,
   orchestrationQuotaFallbackAgent,
   orchestrationQuotaOnLimit,
+  resolveAgentExecutable,
   resolveClaudeExecutable,
   resolveEffectiveIssueSource,
   resolveNewThreadOptions,
   resolveThreadDefaults,
   saveAppSettings,
   updateAdvancedSettings,
+  updateAgentExecutable,
   updateAppEnvironment,
   updateBrightsySettings,
   updateClaudeSettings,
+  updateCodexSettings,
   updateDefaultsSettings,
-  updateIntegrationsSettings
-} from "./chunk-6CUJQKTJ.js";
+  updateIntegrationsSettings,
+  updateOpencodeSettings
+} from "./chunk-MHR4OGZ4.js";
 import {
   FAMOUS_SOCCER_TEAMS,
   addPrStackLayer,
@@ -221,7 +232,7 @@ import {
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-UGXSSBFJ.js";
+} from "./chunk-R7GUDEPY.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -273,12 +284,16 @@ import {
   worktreesRoot
 } from "./chunk-M37RITA6.js";
 import {
+  enrichPathWithNpmGlobalBin,
   ensureAgentPath,
   gh,
   git,
+  posixShellSingleQuote,
+  resolveCommandBinarySync,
   resolveGhAuthToken,
-  run
-} from "./chunk-73AT5K4A.js";
+  run,
+  withExportedPath
+} from "./chunk-TXQ6K2GR.js";
 
 // src/integrations/github.ts
 async function getGitHubStatus() {
@@ -707,9 +722,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-LALWQWRJ.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-44UG64NA.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-N2R6FGZK.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-ILSULI7C.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -911,6 +926,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):",
@@ -996,11 +1014,13 @@ ${prompt}`;
 // src/detect/detect.ts
 async function detectAgents() {
   ensureAgentPath();
+  enrichPathWithNpmGlobalBin();
   return Promise.all(allAdapters().map((a) => a.detect()));
 }
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
 async function requireAgent(agent, opts) {
   ensureAgentPath();
+  enrichPathWithNpmGlobalBin();
   const status = await Promise.race([
     getAdapter(agent).detect(),
     new Promise((_, reject) => {
@@ -2842,7 +2862,7 @@ async function previewLand(thread) {
   const target = await resolveDefaultBranch(thread.repoPath);
   if (thread.branchName === target || thread.branchName === "main" || thread.branchName === "master") {
   }
-  const { stdout: head } = await import("./run-GPSVV5OH.js").then(
+  const { stdout: head } = await import("./run-JLN5JK7Q.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], thread.worktreePath)
   );
   const current = head.trim();
@@ -2881,7 +2901,7 @@ async function confirmLand(thread, opts) {
   if (preview.dirty) {
     committed = await commitAll(thread.worktreePath, meta.commitMessage);
   }
-  const { git: git2 } = await import("./run-GPSVV5OH.js");
+  const { git: git2 } = await import("./run-JLN5JK7Q.js");
   const { stdout: headOut } = await git2(
     ["rev-parse", "--abbrev-ref", "HEAD"],
     thread.worktreePath,
@@ -2979,7 +2999,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-QLSFIQAO.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-EWFD765A.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3507,7 +3527,7 @@ async function adoptThread(input) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
-  const { stdout: branch } = await import("./run-GPSVV5OH.js").then(
+  const { stdout: branch } = await import("./run-JLN5JK7Q.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], input.worktreePath)
   );
   const thread = createEmptyThread({
@@ -3522,7 +3542,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-VCAIHVIE.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-OVBCSS5Y.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -4473,7 +4493,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled: autoCleanupOrphansEnabled2 } = await import("./app-settings-HK4KAM4R.js");
+      const { autoCleanupOrphansEnabled: autoCleanupOrphansEnabled2 } = await import("./app-settings-ONKMFSEJ.js");
       if (autoCleanupOrphansEnabled2() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -4630,7 +4650,7 @@ var Orchestrator = class {
   }
   async finishCreateThread(threadId, prompt) {
     await this.runSetupAfterCreate(threadId);
-    const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await import("./app-settings-HK4KAM4R.js");
+    const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await import("./app-settings-ONKMFSEJ.js");
     if (autoRunAfterSetupEnabled2()) {
       try {
         await this.startDev(threadId);
@@ -4871,13 +4891,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: [] });
     }
@@ -4901,11 +4922,10 @@ var Orchestrator = class {
     });
     const artifactDirective = isBrightsy ? null : formatArtifactDirective();
     const settings = loadWorkspaceSettings(fresh.worktreePath, fresh.repoPath);
-    const { autoRenameBranchEnabled: autoRenameBranchEnabled2 } = await import("./app-settings-HK4KAM4R.js");
+    const { autoRenameBranchEnabled: autoRenameBranchEnabled2 } = await import("./app-settings-ONKMFSEJ.js");
     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);
@@ -4926,12 +4946,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 = [];
@@ -5018,15 +5038,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(
@@ -5596,7 +5612,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled: autoArchiveOnMergeEnabled2 } = await import("./app-settings-HK4KAM4R.js");
+    const { autoArchiveOnMergeEnabled: autoArchiveOnMergeEnabled2 } = await import("./app-settings-ONKMFSEJ.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -5820,7 +5836,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-VCAIHVIE.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-OVBCSS5Y.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -5841,7 +5857,7 @@ var Orchestrator = class {
         await runArchiveScript(thread.repoPath, thread.worktreePath);
       } catch {
       }
-      const { deleteBranchOnPurgeEnabled: deleteBranchOnPurgeEnabled2 } = await import("./app-settings-HK4KAM4R.js");
+      const { deleteBranchOnPurgeEnabled: deleteBranchOnPurgeEnabled2 } = await import("./app-settings-ONKMFSEJ.js");
       const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled2();
       await removeWorktree(thread.repoPath, thread.worktreePath, {
         deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -5862,7 +5878,7 @@ var Orchestrator = class {
       return restored2;
     }
     if (!existsSync13(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-MV4WRW6G.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-K2JB53R5.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
@@ -5971,7 +5987,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-MV4WRW6G.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-K2JB53R5.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return createThread({
@@ -6127,7 +6143,7 @@ function withTimeout(promise, ms, label) {
 async function startMcpServer() {
   const orch = getOrchestrator();
   try {
-    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-HK4KAM4R.js");
+    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-ONKMFSEJ.js");
     orch.setMaxConcurrent(maxConcurrentAgents2());
   } catch {
   }
@@ -6218,14 +6234,13 @@ async function startMcpServer() {
       ),
       artifact_id: 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) }] };
@@ -6278,7 +6293,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) }] };
@@ -6308,9 +6322,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) }] };
@@ -6338,739 +6349,741 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
-  const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-HK4KAM4R.js");
-  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: z.enum(["branch", "pr", "ticket"]),
-      sourceRef: z.string(),
-      agent: z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
-      model: 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: z.string(),
-      title: z.string().optional(),
-      parentThreadId: 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 import("./app-settings-ONKMFSEJ.js");
+    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: z.enum(["branch", "pr", "ticket"]),
+        sourceRef: z.string(),
+        agent: z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
+        model: 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: z.string(),
+        title: z.string().optional(),
+        parentThreadId: 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: z.string(),
+        prompt: z.string(),
+        force_stop: 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: z.string(),
+        timeoutMs: 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: z.string(),
-      prompt: z.string(),
-      force_stop: 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: 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: z.string(),
-      timeoutMs: 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: 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: z.string(),
-      force: 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: z.string(),
+        force: 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: 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: 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: 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: z.string() },
-    async ({ ref }) => {
-      try {
-        const restored = await orch.restore(ref);
+    );
+    server.tool(
+      "get_diff",
+      "Compact diff summary (capped hunks, paginated)",
+      {
+        ref: z.string(),
+        maxFiles: 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: z.string(),
-      maxFiles: 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: 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 = 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: z.string().describe("Worktree thread id/ref to fork"),
+        through_index: 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: z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: 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: z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: 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: z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: 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: 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: z.string(),
+        name: 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 = 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: 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: z.string().describe("Worktree thread id/ref to fork"),
-      through_index: 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: z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-      title: 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: z.string(),
+        name: 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: 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: 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: 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: z.string(),
+        agents: z.array(z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: z.string(),
+        sourceType: z.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: z.string().optional(),
+        title: 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: z.string(),
+        unmergedOnly: 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: z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-      through_index: 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: z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-      title: 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: 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: 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: z.string(),
+        layer: 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: z.string(),
+        branchName: z.string(),
+        title: 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: z.string(),
+        branches: z.array(z.string()).min(1),
+        agent: z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: z.string().optional(),
+        title: 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: z.string(),
-      name: 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: 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: z.string(),
-      name: 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: 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: 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: 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: z.string(),
-      agents: z.array(z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-      repoPath: z.string(),
-      sourceType: z.enum(["branch", "pr", "ticket"]).optional(),
-      sourceRef: z.string().optional(),
-      title: 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: z.string(),
-      unmergedOnly: 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: 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: 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: z.string(),
-      layer: 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: z.string(),
-      branchName: z.string(),
-      title: 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: z.string(),
-      branches: z.array(z.string()).min(1),
-      agent: z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-      base: z.string().optional(),
-      title: 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: 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: z.enum(["claude", "codex", "opencode"]),
-      repoPath: 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: 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: z.enum(["claude", "codex", "opencode"]),
+        repoPath: z.string()
+      },
+      async ({ agent, repoPath }) => {
+        const issues = await listLinearIssues(agent, repoPath);
+        return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
+      }
+    );
+  }
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
@@ -7436,6 +7449,7 @@ export {
   REVIEW_REQUEST_PREFILL,
   SIDEBOARD_FORCE_STOP,
   SIDEBOARD_MCP_ALLOWED_TOOLS,
+  SIDEBOARD_MCP_PROFILE_ENV,
   THINKING_EFFORTS,
   addPrStackLayer,
   addStackLayerFromThread,
@@ -7467,6 +7481,7 @@ export {
   brightsyCloudConnectAgent,
   brightsyCloudConnectEnabled,
   brightsyConfigPath,
+  brightsyInjectWorktreeMcpEnabled,
   brightsyMcpAllowedTools,
   brightsyMcpServerName,
   buildCachedUserContent,
@@ -7518,7 +7533,9 @@ export {
   detectLocalMergeConflicts,
   disconnectBrightsyTeam,
   discoverSkills,
+  dropCachedPrefixOnResume,
   encodeBrightsyTarget,
+  enrichPathWithNpmGlobalBin,
   enrichWorkspacesWithGithub,
   ensureAgentPath,
   ensureCloudCoordinator,
@@ -7556,6 +7573,7 @@ export {
   formatTranscriptMarkdown,
   formatWorkspaceInventory,
   formatWorktreeDirective,
+  formatWorktreeReminder,
   getAdapter,
   getAgentSetupInfo,
   getBrightsySession,
@@ -7682,7 +7700,10 @@ export {
   pastedTextStats,
   permissionMode,
   planFileAbs,
+  posixShellSingleQuote,
+  prepareTerminalCommand,
   previewLand,
+  promptMentionsBrightsy,
   pushBranch,
   readExistingReviewRequestFile,
   readPlanFile,
@@ -7698,7 +7719,9 @@ export {
   requestReview,
   requireAgent,
   resetGhStackDetectCache,
+  resolveAgentExecutable,
   resolveClaudeExecutable,
+  resolveCommandBinarySync,
   resolveConductorCursorAgentId,
   resolveCursorModelId,
   resolveDefaultBranch,
@@ -7707,6 +7730,7 @@ export {
   resolveFilesToCopy,
   resolveGhAuthToken,
   resolveGithubRepoSlug,
+  resolveLoginCommand,
   resolveNewThreadOptions,
   resolvePlanMarkdown,
   resolvePrSelector,
@@ -7728,9 +7752,11 @@ export {
   settingsSourceLabel,
   shouldAttachPastedText,
   shouldCompactContext,
+  shouldInjectBrightsyMcp,
   shouldRefreshReviewRequestTemplate,
   shouldRunWorktreeCleanup,
   sideboardHomeDir,
+  sideboardMcpProfile,
   sideboardReposDir,
   sideboardWorkspacesDir,
   slugify,
@@ -7758,6 +7784,7 @@ export {
   threadDisplayLabel,
   threadFilePath,
   threadLockPath,
+  threadRequestsBrightsyMcp,
   threadsDir,
   threadsSharingWorktree,
   toolDescription,
@@ -7765,14 +7792,18 @@ export {
   toolFilePath,
   totalTokens,
   updateAdvancedSettings,
+  updateAgentExecutable,
   updateAppEnvironment,
   updateBrightsySettings,
   updateClaudeSettings,
+  updateCodexSettings,
   updateDefaultsSettings,
   updateIntegrationsSettings,
+  updateOpencodeSettings,
   updateThread,
   validateLinearApiKey,
   withAgentInstructions,
+  withExportedPath,
   withThreadLock,
   workspaceSettingsSourceLabel,
   worktreeCleanupSettings,