@sideboard-ai/core 0.1.86 → 0.1.87

package/dist/mcp/run-stdio.js

@@ -17,14 +17,14 @@ import {
   resolveQuotaFallbackAgent,
   sideboardMcpProfile,
   summarizeTurnStderr
-} from "../chunk-KE6QLNTJ.js";
-import "../chunk-6K5VAPVR.js";
+} from "../chunk-QWNROSRB.js";
+import "../chunk-DKHGWYWR.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "../chunk-45U4RQ74.js";
+} from "../chunk-R2EOZNQI.js";
 import {
   extractPresentedPlan,
   readPlanFile,
@@ -32,7 +32,7 @@ import {
 } from "../chunk-N5PM7HGQ.js";
 import {
   releaseCaffeinateHoldForThread
-} from "../chunk-RV6DBEDQ.js";
+} from "../chunk-7KDBDMNC.js";
 import {
   GLOBAL_WORKSPACE_ID,
   assertOrchestratorCapableAgent,
@@ -42,14 +42,14 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "../chunk-EWKHP6DD.js";
+} from "../chunk-UVNXLTFB.js";
 import {
   SLACK_REPLY_FORMATTING,
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "../chunk-HA2QTIWN.js";
+} from "../chunk-3MA6JH6G.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -89,7 +89,7 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeNameFromPath
-} from "../chunk-6ZGTM2E7.js";
+} from "../chunk-CY45C3GA.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -106,7 +106,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "../chunk-7FD7COKE.js";
+} from "../chunk-JOF3XIEM.js";
 import {
   childEnvWithAppSettings,
   disconnectLinearConnection,
@@ -124,20 +124,22 @@ import {
   stripNestedElectronEnv,
   updateAdvancedSettings,
   writeSecureJson
-} from "../chunk-AY53MPDE.js";
+} from "../chunk-TC2KY5G7.js";
 import {
   writePrivateFile
 } from "../chunk-NSTQ6QKD.js";
 import "../chunk-KGZBYWZ3.js";
 import {
   appDataDir,
+  findConventionSetup,
   loadRepoSettings,
   loadWorkspaceSettings,
+  runCursorWorktreeSetup,
   sideboardReposDir,
   sideboardWorkspacesDir,
   workspaceSettingsSourceLabel,
   worktreesRoot
-} from "../chunk-7MV3RXSC.js";
+} from "../chunk-JL4SJ6V7.js";
 import {
   enrichPathWithNpmGlobalBin,
   ensureAgentPath,
@@ -652,7 +654,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 
 // src/agents/spawn.ts
 import { createInterface } from "readline";
@@ -894,9 +896,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-MXOLTUAR.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-T5IAJF4R.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-L65MIGCV.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-PYRAXZN3.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1326,6 +1328,14 @@ async function spawnWorkspaceScript(command, opts) {
     child
   };
 }
+async function attachAbort(handle, signal) {
+  if (signal) {
+    const onAbort = () => handle.kill();
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return handle.done;
+}
 async function runSetupScript(repoPath, worktreePath, onLine, opts) {
   const settings = loadWorkspaceSettings(worktreePath, repoPath);
   if (!settings?.setup) return { ran: false, exitCode: null, source: null };
@@ -1335,12 +1345,7 @@ async function runSetupScript(repoPath, worktreePath, onLine, opts) {
     defaultBranch: opts?.defaultBranch,
     onLine
   });
-  if (opts?.signal) {
-    const onAbort = () => handle.kill();
-    if (opts.signal.aborted) onAbort();
-    else opts.signal.addEventListener("abort", onAbort, { once: true });
-  }
-  const exitCode = await handle.done;
+  const exitCode = await attachAbort(handle, opts?.signal);
   return {
     ran: true,
     exitCode,
@@ -1348,6 +1353,34 @@ async function runSetupScript(repoPath, worktreePath, onLine, opts) {
     kill: handle.kill
   };
 }
+async function runConventionSetup(repoPath, worktreePath, onLine, opts) {
+  const found = findConventionSetup(worktreePath, repoPath);
+  if (!found) return { ran: false, exitCode: null, source: null };
+  onLine?.(`[setup] ${found.source}`);
+  const handle = await spawnWorkspaceScript(found.command, {
+    worktreePath,
+    repoPath,
+    defaultBranch: opts?.defaultBranch,
+    onLine
+  });
+  const exitCode = await attachAbort(handle, opts?.signal);
+  return {
+    ran: true,
+    exitCode,
+    source: found.source,
+    kill: handle.kill
+  };
+}
+async function runWorkspaceSetup(repoPath, worktreePath, onLine, opts) {
+  let setup = await runSetupScript(repoPath, worktreePath, onLine, opts);
+  if (!setup.ran) {
+    setup = await runCursorWorktreeSetup(repoPath, worktreePath, onLine);
+  }
+  if (!setup.ran) {
+    setup = await runConventionSetup(repoPath, worktreePath, onLine, opts);
+  }
+  return setup;
+}
 async function runArchiveScript(repoPath, worktreePath, onLine) {
   const settings = loadWorkspaceSettings(worktreePath, repoPath);
   if (!settings?.archive) return { ran: false, exitCode: null };
@@ -1440,75 +1473,9 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
   };
 }
 
-// src/hook/cursor-worktrees.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
-import { execa as execa3 } from "execa";
-import { createInterface as createInterface3 } from "readline";
-function loadCursorWorktreesJson(rootPath) {
-  const path = join5(rootPath, ".cursor", "worktrees.json");
-  if (!existsSync4(path)) return null;
-  try {
-    return JSON.parse(readFileSync4(path, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function resolveSetupSpec(config) {
-  if (process.platform === "win32") {
-    return config["setup-worktree-windows"] ?? config["setup-worktree"] ?? null;
-  }
-  return config["setup-worktree-unix"] ?? config["setup-worktree"] ?? null;
-}
-async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
-  const fromWorktree = loadCursorWorktreesJson(worktreePath);
-  const fromRepo = worktreePath !== repoPath ? loadCursorWorktreesJson(repoPath) : null;
-  const config = fromWorktree ?? fromRepo;
-  if (!config) return { ran: false, exitCode: null, source: null };
-  const spec = resolveSetupSpec(config);
-  if (!spec) return { ran: false, exitCode: null, source: null };
-  const sourceLabel = fromWorktree ? ".cursor/worktrees.json (worktree)" : ".cursor/worktrees.json (main repo)";
-  const env = {
-    ...process.env,
-    ROOT_WORKTREE_PATH: repoPath
-  };
-  if (process.platform === "win32") {
-    env.ROOT_WORKTREE_PATH = repoPath;
-  }
-  const commands = Array.isArray(spec) ? spec : [spec.endsWith(".sh") || spec.endsWith(".ps1") ? join5(
-    fromWorktree ? worktreePath : repoPath,
-    ".cursor",
-    spec
-  ) : spec];
-  let lastExit = 0;
-  for (const command of commands) {
-    const isScriptPath = typeof spec === "string" && (spec.endsWith(".sh") || spec.endsWith(".ps1"));
-    const shell = process.platform === "win32" ? "powershell" : "bash";
-    const args = process.platform === "win32" ? isScriptPath ? ["-File", command] : ["-Command", command] : isScriptPath ? [command] : ["-lc", command];
-    onLine?.(`[cursor setup] ${command}`);
-    const child = execa3(shell, args, {
-      cwd: worktreePath,
-      reject: false,
-      env
-    });
-    if (child.stdout && onLine) {
-      const rl = createInterface3({ input: child.stdout });
-      rl.on("line", onLine);
-    }
-    if (child.stderr && onLine) {
-      const rl = createInterface3({ input: child.stderr });
-      rl.on("line", onLine);
-    }
-    const result = await child;
-    lastExit = result.exitCode ?? null;
-    if (lastExit !== 0 && lastExit !== null) break;
-  }
-  return { ran: true, exitCode: lastExit, source: sourceLabel };
-}
-
 // src/git/orphan-cleanup.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join5 } from "path";
 function isSideboardWorktreePath(path) {
   return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
 }
@@ -1519,7 +1486,7 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if (existsSync5(homeRoot)) {
+  if (existsSync4(homeRoot)) {
     try {
       for (const entry of readdirSync2(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -1531,7 +1498,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !existsSync5(repoPath)) continue;
+    if (!repoPath || !existsSync4(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -1552,12 +1519,12 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if (existsSync5(root)) {
+      if (existsSync4(root)) {
         for (const entry of readdirSync2(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = join6(root, entry.name).replace(/\/$/, "");
+          const path = join5(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!existsSync5(join6(path, ".git"))) continue;
+          if (!existsSync4(join5(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
@@ -1615,11 +1582,11 @@ function shouldRunWorktreeCleanup(settings = loadAppSettings()) {
 }
 
 // src/git/apply-into-main.ts
-import { execa as execa4 } from "execa";
+import { execa as execa3 } from "execa";
 async function applyThreadIntoMain(thread, opts) {
   const method = opts?.method ?? "merge";
   const target = opts?.targetBranch?.trim() || await resolveDefaultBranch(thread.repoPath);
-  const status = await execa4("git", ["status", "--porcelain"], {
+  const status = await execa3("git", ["status", "--porcelain"], {
     cwd: thread.repoPath,
     reject: false
   });
@@ -1628,7 +1595,7 @@ async function applyThreadIntoMain(thread, opts) {
       `Main checkout is dirty \u2014 commit or stash before apply-into-main (${thread.repoPath})`
     );
   }
-  const checkout = await execa4("git", ["checkout", target], {
+  const checkout = await execa3("git", ["checkout", target], {
     cwd: thread.repoPath,
     reject: false
   });
@@ -1638,7 +1605,7 @@ async function applyThreadIntoMain(thread, opts) {
     );
   }
   if (method === "cherry-pick") {
-    const log = await execa4(
+    const log = await execa3(
       "git",
       ["log", "--reverse", "--format=%H", `${target}..${thread.branchName}`],
       { cwd: thread.repoPath, reject: false }
@@ -1653,12 +1620,12 @@ async function applyThreadIntoMain(thread, opts) {
       };
     }
     for (const sha of shas) {
-      const cp = await execa4("git", ["cherry-pick", sha], {
+      const cp = await execa3("git", ["cherry-pick", sha], {
         cwd: thread.repoPath,
         reject: false
       });
       if (cp.exitCode !== 0) {
-        await execa4("git", ["cherry-pick", "--abort"], {
+        await execa3("git", ["cherry-pick", "--abort"], {
           cwd: thread.repoPath,
           reject: false
         });
@@ -1674,13 +1641,13 @@ async function applyThreadIntoMain(thread, opts) {
       message: `Cherry-picked ${shas.length} commit(s) from ${thread.branchName} into ${target}`
     };
   }
-  const merge = await execa4(
+  const merge = await execa3(
     "git",
     ["merge", "--no-ff", "-m", `Apply Sideboard thread ${thread.branchName}`, thread.branchName],
     { cwd: thread.repoPath, reject: false }
   );
   if (merge.exitCode !== 0) {
-    await execa4("git", ["merge", "--abort"], {
+    await execa3("git", ["merge", "--abort"], {
       cwd: thread.repoPath,
       reject: false
     });
@@ -1697,9 +1664,9 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-import { existsSync as existsSync6 } from "fs";
-import { basename as basename2, join as join7 } from "path";
-import { execa as execa5 } from "execa";
+import { existsSync as existsSync5 } from "fs";
+import { basename as basename2, join as join6 } from "path";
+import { execa as execa4 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
   const url = opts.url.trim();
   if (!url) throw new Error("Clone URL is required");
@@ -1709,13 +1676,13 @@ async function cloneRepoIntoSideboard(opts) {
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = join7(sideboardReposDir(), name);
-  if (existsSync6(dest)) {
+  const dest = join6(sideboardReposDir(), name);
+  if (existsSync5(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
   }
-  const result = await execa5("git", ["clone", url, dest], { reject: false });
+  const result = await execa4("git", ["clone", url, dest], { reject: false });
   if (result.exitCode !== 0) {
     throw new Error(
       `git clone failed: ${result.stderr?.trim() || result.stdout?.trim() || `exit ${result.exitCode}`}`
@@ -1727,7 +1694,7 @@ async function cloneRepoIntoSideboard(opts) {
 }
 
 // src/threads/create.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 
 // src/detect/detect.ts
 var REQUIRE_AGENT_TIMEOUT_MS = 8e3;
@@ -1767,7 +1734,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync7(repoPath)) {
+  if (!existsSync6(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -1825,7 +1792,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-NDHD3VOL.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-W5446HSV.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2219,8 +2186,8 @@ function forkChatTab(input) {
 
 // src/review/request-review.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync } from "fs";
-import { dirname as dirname2, join as join8 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
 
 // src/review/review-request-template.ts
 var REVIEW_REQUEST_TEMPLATE = `# Review guidelines:
@@ -2365,22 +2332,22 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!existsSync8(abs)) return null;
+  if (!existsSync7(abs)) return null;
   try {
-    const content = readFileSync5(abs, "utf8");
+    const content = readFileSync4(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = join8(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if (existsSync8(gitignoreAbs)) return;
+  const gitignoreAbs = join7(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if (existsSync7(gitignoreAbs)) return;
   mkdirSync2(dirname2(gitignoreAbs), { recursive: true });
   writeFileSync(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
-  const repoAbs = join8(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = join7(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -2390,7 +2357,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = join8(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = join7(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return {
@@ -2400,7 +2367,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
-  const legacyAbs = join8(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = join7(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return {
@@ -2608,23 +2575,23 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 import { execFileSync } from "child_process";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync9,
+  existsSync as existsSync8,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync5,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 import Database from "better-sqlite3";
-var CONDUCTOR_APP_SUPPORT = join9(
+var CONDUCTOR_APP_SUPPORT = join8(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join9(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join9(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join8(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join8(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -2636,7 +2603,7 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync9(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync8(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
@@ -2646,11 +2613,11 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join9(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync9(agentsFile)) continue;
+    const agentsFile = join8(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!existsSync8(agentsFile)) continue;
     let text3;
     try {
-      text3 = readFileSync6(agentsFile, "utf8");
+      text3 = readFileSync5(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -2674,7 +2641,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync9(input.worktreePath)) {
+  if (!existsSync8(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -2693,21 +2660,21 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-VWQ5YSND.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-J4ULXOUH.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!existsSync9(CONDUCTOR_DB)) {
+  if (!existsSync8(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join9(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join9(tmp, "conductor.db");
+  const tmp = mkdtempSync(join8(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join8(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync9(src)) {
+      if (existsSync8(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -2789,16 +2756,16 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync9(CONDUCTOR_DB)) {
+  if (!existsSync8(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join9(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join9(tmp, "conductor.db");
+  const tmp = mkdtempSync(join8(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join8(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync9(src)) {
+      if (existsSync8(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -2818,7 +2785,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync9(worktreePath)) {
+      if (!existsSync8(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -2889,7 +2856,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 function stackIdFrom(stack) {
   if (stack.stackNumber != null) return `gh-stack-${stack.stackNumber}`;
   const key = stack.layers.map((l) => l.branchName).join("|");
@@ -2952,7 +2919,7 @@ async function openStackLayer(input, _onSetupLine) {
   let createdWorktree = false;
   const trees = await listWorktrees(repoPath);
   const checkedOut = trees.find((w) => w.branch === branchName);
-  if (checkedOut?.path && existsSync10(checkedOut.path)) {
+  if (checkedOut?.path && existsSync9(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -3094,7 +3061,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync10(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!existsSync9(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
   if (!input.branches.length) throw new Error("At least one branch name required");
   const status = await detectGhStack(repoPath);
   if (!status.available) throw new Error(status.reason);
@@ -3161,7 +3128,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && existsSync10(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && existsSync9(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -3173,10 +3140,10 @@ async function createPrStack(input, onSetupLine) {
 }
 
 // src/diff/diff.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !existsSync11(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !existsSync10(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -3184,7 +3151,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !existsSync11(worktreePath)) {
+  if (!worktreePath || !existsSync10(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -3319,11 +3286,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = join10(worktreePath, path);
+  const abs = join9(worktreePath, path);
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = readFileSync7(abs).subarray(0, maxHunk);
+      const buf = readFileSync6(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -3824,7 +3791,7 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = join10(worktreePath, relativePath);
+  const abs = join9(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -3834,7 +3801,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = readFileSync7(abs);
+  const buf = readFileSync6(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -3844,12 +3811,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = join10(worktreePath, relativePath);
+  const abs = join9(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = readFileSync7(abs);
+  const buf = readFileSync6(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -3892,7 +3859,7 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = join10(worktreePath, relativePath);
+  const abs = join9(worktreePath, relativePath);
   mkdirSync3(dirname3(abs), { recursive: true });
   writeFileSync2(abs, content, "utf8");
   return { path: relativePath };
@@ -3997,9 +3964,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
 import { homedir } from "os";
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -4031,7 +3998,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = readFileSync8(skillMd, "utf8");
+    const content = readFileSync7(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -4050,7 +4017,7 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync12(dir)) return;
+  if (!existsSync11(dir)) return;
   let entries;
   try {
     entries = readdirSync4(dir);
@@ -4059,8 +4026,8 @@ function scanSkillsDir(dir, source, out) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = join11(dir, entry, "SKILL.md");
-    if (!existsSync12(skillMd)) continue;
+    const skillMd = join10(dir, entry, "SKILL.md");
+    if (!existsSync11(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
     } catch {
@@ -4071,7 +4038,7 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!existsSync12(pluginsRoot)) return;
+  if (!existsSync11(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
@@ -4081,12 +4048,12 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill(join11(dir, "SKILL.md"), "cli");
+      const skill = readSkill(join10(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join11(dir, entry);
+      const full = join10(dir, entry);
       try {
         if (!statSync3(full).isDirectory()) continue;
       } catch {
@@ -4106,17 +4073,17 @@ function discoverSkills(worktreePath) {
   const home = homedir();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir(join11(worktreePath, rel), "workspace", collected);
+    scanSkillsDir(join10(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    join11(home, ".claude/skills"),
-    join11(home, ".cursor/skills"),
-    join11(home, ".sideboard/skills"),
-    join11(home, ".brightsy/skills")
+    join10(home, ".claude/skills"),
+    join10(home, ".cursor/skills"),
+    join10(home, ".sideboard/skills"),
+    join10(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills(join11(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills(join10(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -4128,7 +4095,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = readFileSync8(skillPath, "utf8");
+  const raw = readFileSync7(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -4221,8 +4188,8 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync9, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
-import { basename as basename3, extname, join as join12 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename3, extname, join as join11 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
@@ -4257,22 +4224,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = join12(worktreePath, ATTACHMENTS_DIR);
+  const dir = join11(worktreePath, ATTACHMENTS_DIR);
   mkdirSync4(dir, { recursive: true });
-  const gi = join12(dir, ".gitignore");
-  if (!existsSync13(gi)) {
+  const gi = join11(dir, ".gitignore");
+  if (!existsSync12(gi)) {
     writeFileSync3(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!existsSync13(join12(dir, safe))) return safe;
+  if (!existsSync12(join11(dir, safe))) return safe;
   const ext = extname(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!existsSync13(join12(dir, candidate))) return candidate;
+    if (!existsSync12(join11(dir, candidate))) return candidate;
   }
   return `${stem}-${randomUUID4()}${ext}`;
 }
@@ -4333,10 +4300,10 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
       const st = statSync4(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = join12(dir, name);
+      const destAbs = join11(dir, name);
       copyFileSync3(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = readFileSync9(destAbs);
+      const buf = readFileSync8(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -4358,7 +4325,7 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = join12(dir, name);
+      const destAbs = join11(dir, name);
       writeFileSync3(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
@@ -4387,10 +4354,10 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     }
     const name = basename3(rel);
     try {
-      const abs = join12(worktreePath, rel);
+      const abs = join11(worktreePath, rel);
       const st = statSync4(abs);
       if (!st.isFile()) continue;
-      const buf = readFileSync9(abs);
+      const buf = readFileSync8(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -4405,8 +4372,8 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
+import { join as join12 } from "path";
 function normPath(p) {
   return p.replace(/\/+$/, "");
 }
@@ -4666,7 +4633,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync15(thread.worktreePath)) {
+      if (!existsSync14(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -4685,7 +4652,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("../app-settings-PEXK5VEX.js");
+      const { autoCleanupOrphansEnabled } = await import("../app-settings-F36ISTCF.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -4841,14 +4808,7 @@ var Orchestrator = class {
     return thread;
   }
   async finishCreateThread(threadId, prompt) {
-    await this.runSetupAfterCreate(threadId);
-    const { autoRunAfterSetupEnabled } = await import("../app-settings-PEXK5VEX.js");
-    if (autoRunAfterSetupEnabled()) {
-      try {
-        await this.startDev(threadId);
-      } catch {
-      }
-    }
+    const setup = this.runSetupAfterCreate(threadId);
     if (prompt) {
       try {
         await this.send(threadId, prompt);
@@ -4859,6 +4819,14 @@ var Orchestrator = class {
         });
       }
     }
+    await setup;
+    const { autoRunAfterSetupEnabled } = await import("../app-settings-F36ISTCF.js");
+    if (autoRunAfterSetupEnabled()) {
+      try {
+        await this.startDev(threadId);
+      } catch {
+      }
+    }
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -5113,7 +5081,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("../app-settings-PEXK5VEX.js");
+    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("../app-settings-F36ISTCF.js");
     const gitAuthMode = getGithubGitAuthMode();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -5206,7 +5174,7 @@ var Orchestrator = class {
       if (this.requireThread(threadId).agent === "cursor" && exitCode !== 0 && !assistantText && parts.length === 0) {
         const sessionId = result.sessionId || this.requireThread(threadId).sessionId || "";
         if (sessionId) {
-          const { recoverFinishedCursorRun } = await import("../cursor-recover-NNK7JPQM.js");
+          const { recoverFinishedCursorRun } = await import("../cursor-recover-S5ORPW34.js");
           for (let i = 0; i < 8; i++) {
             const recovered = recoverFinishedCursorRun({
               agentId: sessionId,
@@ -5556,7 +5524,7 @@ var Orchestrator = class {
     });
     this.emit({ type: "setup_started", threadId: thread.id });
     try {
-      let setup = await runSetupScript(
+      const setup = await runWorkspaceSetup(
         thread.repoPath,
         thread.worktreePath,
         (line) => {
@@ -5564,18 +5532,9 @@ var Orchestrator = class {
         },
         { signal: abort.signal }
       );
-      if (!setup.ran) {
-        setup = await runCursorWorktreeSetup(
-          thread.repoPath,
-          thread.worktreePath,
-          (line) => {
-            this.emit({ type: "setup_output", threadId: thread.id, line });
-          }
-        );
-      }
       if (!setup.ran) {
         throw new Error(
-          "No setup script in .sideboard/settings.toml, .conductor/settings.toml, or .cursor/worktrees.json"
+          "No setup script in .sideboard/settings.toml, .conductor/settings.toml, .cursor/worktrees.json, or script/setup (bin/setup, scripts/setup)"
         );
       }
       if (setup.exitCode !== 0 && setup.exitCode !== null) {
@@ -5830,7 +5789,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("../app-settings-PEXK5VEX.js");
+    const { autoArchiveOnMergeEnabled } = await import("../app-settings-F36ISTCF.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -5883,7 +5842,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: t.id, status: t.status });
     }
     for (const id of result.createdThreadIds) {
-      await this.runSetupAfterCreate(id);
+      void this.runSetupAfterCreate(id);
     }
     return { stack: result.stack, threads: result.threads };
   }
@@ -5900,7 +5859,7 @@ var Orchestrator = class {
       status: result.thread.status
     });
     if (result.createdWorktree) {
-      await this.runSetupAfterCreate(result.thread.id);
+      void this.runSetupAfterCreate(result.thread.id);
     }
     return { stack: result.stack, thread: result.thread };
   }
@@ -5915,7 +5874,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: t.id, status: t.status });
     }
     for (const id of result.createdThreadIds) {
-      await this.runSetupAfterCreate(id);
+      void this.runSetupAfterCreate(id);
     }
     return { stack: result.stack, threads: result.threads };
   }
@@ -5926,7 +5885,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: t.id, status: t.status });
     }
     for (const id of result.createdThreadIds) {
-      await this.runSetupAfterCreate(id);
+      void this.runSetupAfterCreate(id);
     }
     return { stack: result.stack, threads: result.threads };
   }
@@ -6057,7 +6016,7 @@ var Orchestrator = class {
   async forkThreadWorktree(input) {
     const thread = await forkThreadWorktree(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.runSetupAfterCreate(thread.id);
     return thread;
   }
   renameThread(threadRef, title) {
@@ -6118,7 +6077,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-VWQ5YSND.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-J4ULXOUH.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -6140,7 +6099,7 @@ var Orchestrator = class {
         await runArchiveScript(thread.repoPath, thread.worktreePath);
       } catch {
       }
-      const { deleteBranchOnPurgeEnabled } = await import("../app-settings-PEXK5VEX.js");
+      const { deleteBranchOnPurgeEnabled } = await import("../app-settings-F36ISTCF.js");
       const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
       await removeWorktree(thread.repoPath, thread.worktreePath, {
         deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -6154,18 +6113,18 @@ var Orchestrator = class {
       throw new Error("Thread is not archived");
     }
     if (isGlobalThread(thread)) {
-      const { globalAgentCwd } = await import("../paths-2OFB7UJG.js");
+      const { globalAgentCwd } = await import("../paths-TZX4L5X7.js");
       updateThread(thread.id, { worktreePath: globalAgentCwd() });
       const restored2 = setStatus(thread.id, "idle");
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!existsSync15(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-RFCCG23P.js");
-      const { execa: execa6 } = await import("execa");
+    if (!existsSync14(thread.worktreePath)) {
+      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-4Z2VSHAQ.js");
+      const { execa: execa5 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
-      await execa6("git", ["worktree", "add", dest, thread.branchName], {
+      await execa5("git", ["worktree", "add", dest, thread.branchName], {
         cwd: thread.repoPath
       });
       void createThreadWorktree2;
@@ -7332,7 +7291,7 @@ function withTimeout(promise, ms, label) {
 async function startMcpServer() {
   const orch = getOrchestrator();
   try {
-    const { maxConcurrentAgents } = await import("../app-settings-PEXK5VEX.js");
+    const { maxConcurrentAgents } = await import("../app-settings-F36ISTCF.js");
     orch.setMaxConcurrent(maxConcurrentAgents());
   } catch {
   }
@@ -7541,8 +7500,8 @@ async function startMcpServer() {
   registerSlackTools(server);
   registerLinearTools(server);
   if (sideboardMcpProfile() !== "worktree") {
-    const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-OHAUWOA6.js");
-    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults } = await import("../app-settings-PEXK5VEX.js");
+    const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-U3QJBV67.js");
+    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults } = await import("../app-settings-F36ISTCF.js");
     const accountDefaults = resolveThreadDefaults();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
@@ -7585,7 +7544,7 @@ async function startMcpServer() {
     );
     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.`,
+      `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}. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn. Then use send_to_thread to chat.`,
       {
         sourceType: z3.enum(["branch", "pr", "ticket"]),
         sourceRef: z3.string(),
@@ -8103,7 +8062,7 @@ async function startMcpServer() {
     );
     server.tool(
       "run_setup",
-      "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
+      "Re-run workspace setup (Sideboard/Conductor settings, .cursor/worktrees.json, or script/setup). New worktrees already run this automatically.",
       { ref: z3.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);