@sideboard-ai/core 0.1.62 → 0.1.67

package/dist/mcp/run-stdio.js

@@ -14,15 +14,16 @@ import {
   parseSessionQuotaResetAt,
   pushTurnStderr,
   resolveQuotaFallbackAgent,
+  sideboardMcpProfile,
   summarizeTurnStderr
-} from "../chunk-2MCNURQV.js";
-import "../chunk-JB2H7E7V.js";
+} from "../chunk-K7LM4CLD.js";
+import "../chunk-M5V4QIWF.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "../chunk-A6FOKNOU.js";
+} from "../chunk-5HTTCYWA.js";
 import {
   extractPresentedPlan,
   readPlanFile,
@@ -30,22 +31,20 @@ import {
 } from "../chunk-N5PM7HGQ.js";
 import {
   GLOBAL_WORKSPACE_ID,
+  assertOrchestratorCapableAgent,
   healOrchestrationSoccerTitles,
   isCloudCoordinatorThread,
   isGlobalRepoPath,
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "../chunk-2FEA4LDA.js";
-import {
-  assertOrchestratorCapableAgent
-} from "../chunk-S2LL5HA4.js";
+} from "../chunk-JWZNK3CQ.js";
 import {
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "../chunk-NVU7EC2E.js";
+} from "../chunk-57WWNMFP.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -82,7 +81,7 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeNameFromPath
-} from "../chunk-3KKNTHUC.js";
+} from "../chunk-LW5CMQGZ.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -101,11 +100,12 @@ import {
   writeThread
 } from "../chunk-7FD7COKE.js";
 import {
+  enrichPathWithNpmGlobalBin,
   ensureAgentPath,
   gh,
   git,
   run
-} from "../chunk-RIWUU7FO.js";
+} from "../chunk-FGDJOJ2L.js";
 import {
   childEnvWithAppSettings,
   getLinearApiKey,
@@ -116,7 +116,7 @@ import {
   resolveEffectiveIssueSource,
   resolveNewThreadOptions,
   updateAdvancedSettings
-} from "../chunk-DDN3UF4R.js";
+} from "../chunk-BPOTVI5J.js";
 import "../chunk-KGZBYWZ3.js";
 import {
   loadRepoSettings,
@@ -391,9 +391,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-YOAUQCMA.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-YZ2NJVLL.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-LKG3SHMI.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-6HMTOX4G.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1117,6 +1117,7 @@ import { existsSync as existsSync5 } from "fs";
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
 async function requireAgent(agent, opts) {
   ensureAgentPath();
+  enrichPathWithNpmGlobalBin();
   const status = await Promise.race([
     getAdapter(agent).detect(),
     new Promise((_, reject) => {
@@ -1208,7 +1209,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-KF3J3C53.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-OTBZVTZO.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2057,7 +2058,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-HZTBWGQR.js").then(
+  const { stdout: branch } = await import("../run-Y2MI3EVV.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], input.worktreePath)
   );
   const thread = createEmptyThread({
@@ -2072,7 +2073,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-E75POJXP.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-AIUYUXB7.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -3178,7 +3179,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-HZTBWGQR.js").then(
+  const { stdout: head } = await import("../run-Y2MI3EVV.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], thread.worktreePath)
   );
   const current = head.trim();
@@ -3217,7 +3218,7 @@ async function confirmLand(thread, opts) {
   if (preview.dirty) {
     committed = await commitAll(thread.worktreePath, meta.commitMessage);
   }
-  const { git: git2 } = await import("../run-HZTBWGQR.js");
+  const { git: git2 } = await import("../run-Y2MI3EVV.js");
   const { stdout: headOut } = await git2(
     ["rev-parse", "--abbrev-ref", "HEAD"],
     thread.worktreePath,
@@ -3754,6 +3755,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):",
@@ -3774,60 +3778,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 = join10(worktreePath, rel);
-    if (!existsSync12(abs)) continue;
-    try {
-      if (!statSync5(abs).isFile()) continue;
-      let content = readFileSync8(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/threads/sync-branch.ts
 async function syncThreadBranchFromGit(threadId) {
@@ -3960,7 +3910,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("../app-settings-LTSFG7QJ.js");
+      const { autoCleanupOrphansEnabled } = await import("../app-settings-GJVZGU3M.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -4117,7 +4067,7 @@ var Orchestrator = class {
   }
   async finishCreateThread(threadId, prompt) {
     await this.runSetupAfterCreate(threadId);
-    const { autoRunAfterSetupEnabled } = await import("../app-settings-LTSFG7QJ.js");
+    const { autoRunAfterSetupEnabled } = await import("../app-settings-GJVZGU3M.js");
     if (autoRunAfterSetupEnabled()) {
       try {
         await this.startDev(threadId);
@@ -4358,13 +4308,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: [] });
     }
@@ -4388,11 +4339,10 @@ var Orchestrator = class {
     });
     const artifactDirective = isBrightsy ? null : formatArtifactDirective();
     const settings = loadWorkspaceSettings(fresh.worktreePath, fresh.repoPath);
-    const { autoRenameBranchEnabled } = await import("../app-settings-LTSFG7QJ.js");
+    const { autoRenameBranchEnabled } = await import("../app-settings-GJVZGU3M.js");
     const renameBranchDirective = !isBrightsy && !isOrchestration && autoRenameBranchEnabled() ? 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);
@@ -4413,12 +4363,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 = [];
@@ -4505,15 +4455,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(
@@ -5083,7 +5029,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("../app-settings-LTSFG7QJ.js");
+    const { autoArchiveOnMergeEnabled } = await import("../app-settings-GJVZGU3M.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -5307,7 +5253,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-E75POJXP.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-AIUYUXB7.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -5328,7 +5274,7 @@ var Orchestrator = class {
         await runArchiveScript(thread.repoPath, thread.worktreePath);
       } catch {
       }
-      const { deleteBranchOnPurgeEnabled } = await import("../app-settings-LTSFG7QJ.js");
+      const { deleteBranchOnPurgeEnabled } = await import("../app-settings-GJVZGU3M.js");
       const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
       await removeWorktree(thread.repoPath, thread.worktreePath, {
         deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -5349,7 +5295,7 @@ var Orchestrator = class {
       return restored2;
     }
     if (!existsSync13(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-LZEGVQSN.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-WMDJW2BL.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
@@ -5565,7 +5511,7 @@ function withTimeout(promise, ms, label) {
 async function startMcpServer() {
   const orch = getOrchestrator();
   try {
-    const { maxConcurrentAgents } = await import("../app-settings-LTSFG7QJ.js");
+    const { maxConcurrentAgents } = await import("../app-settings-GJVZGU3M.js");
     orch.setMaxConcurrent(maxConcurrentAgents());
   } catch {
   }
@@ -5656,14 +5602,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) }] };
@@ -5716,7 +5661,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) }] };
@@ -5746,9 +5690,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) }] };
@@ -5776,739 +5717,741 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
-  const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults } = await import("../app-settings-LTSFG7QJ.js");
-  const accountDefaults = resolveThreadDefaults();
-  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 } = await import("../app-settings-GJVZGU3M.js");
+    const accountDefaults = resolveThreadDefaults();
+    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: 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: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
+                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);
 }