@sideboard-ai/core 0.1.98 → 0.1.100

package/dist/index.cjs

@@ -3072,23 +3072,23 @@ var init_gh_errors = __esm({
 function githubAgentAuthDir() {
   const override = process.env.SIDEBOARD_GIT_AUTH_DIR?.trim();
   if (override) return override;
-  return (0, import_node_path10.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
+  return (0, import_node_path11.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
 }
 function githubCredentialStorePath() {
-  return (0, import_node_path10.join)(githubAgentAuthDir(), "git-credentials");
+  return (0, import_node_path11.join)(githubAgentAuthDir(), "git-credentials");
 }
 function githubGhConfigDir() {
-  return (0, import_node_path10.join)(githubAgentAuthDir(), "gh");
+  return (0, import_node_path11.join)(githubAgentAuthDir(), "gh");
 }
 function writePrivateFile2(file, body) {
-  (0, import_node_fs10.mkdirSync)((0, import_node_path10.dirname)(file), { recursive: true, mode: 448 });
+  (0, import_node_fs11.mkdirSync)((0, import_node_path11.dirname)(file), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs10.chmodSync)((0, import_node_path10.dirname)(file), 448);
+    (0, import_node_fs11.chmodSync)((0, import_node_path11.dirname)(file), 448);
   } catch {
   }
-  (0, import_node_fs10.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
+  (0, import_node_fs11.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
   try {
-    (0, import_node_fs10.chmodSync)(file, 384);
+    (0, import_node_fs11.chmodSync)(file, 384);
   } catch {
   }
 }
@@ -3113,19 +3113,19 @@ function materializeGithubAgentAuth(token, user) {
   const trimmed = token.trim();
   if (!trimmed) return;
   const root = githubAgentAuthDir();
-  (0, import_node_fs10.mkdirSync)(root, { recursive: true, mode: 448 });
+  (0, import_node_fs11.mkdirSync)(root, { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs10.chmodSync)(root, 448);
+    (0, import_node_fs11.chmodSync)(root, 448);
   } catch {
   }
   writePrivateFile2(githubCredentialStorePath(), gitCredentialStoreContents(trimmed));
   const ghDir = githubGhConfigDir();
-  (0, import_node_fs10.mkdirSync)(ghDir, { recursive: true, mode: 448 });
-  writePrivateFile2((0, import_node_path10.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
-  writePrivateFile2((0, import_node_path10.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
+  (0, import_node_fs11.mkdirSync)(ghDir, { recursive: true, mode: 448 });
+  writePrivateFile2((0, import_node_path11.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
+  writePrivateFile2((0, import_node_path11.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
 }
 function githubAgentAuthReady() {
-  return (0, import_node_fs10.existsSync)(githubCredentialStorePath()) && (0, import_node_fs10.existsSync)((0, import_node_path10.join)(githubGhConfigDir(), "hosts.yml"));
+  return (0, import_node_fs11.existsSync)(githubCredentialStorePath()) && (0, import_node_fs11.existsSync)((0, import_node_path11.join)(githubGhConfigDir(), "hosts.yml"));
 }
 function githubCredentialHelperGitConfig() {
   const file = githubCredentialStorePath();
@@ -3140,29 +3140,29 @@ function githubGhConfigEnv() {
     GH_PROMPT_DISABLED: "1"
   };
 }
-var import_node_fs10, import_node_os4, import_node_path10;
+var import_node_fs11, import_node_os4, import_node_path11;
 var init_github_agent_auth = __esm({
   "src/git/github-agent-auth.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
+    import_node_fs11 = require("fs");
     import_node_os4 = require("os");
-    import_node_path10 = require("path");
+    import_node_path11 = require("path");
   }
 });
 
 // src/agents/path.ts
 function prependPathDir(env, dir) {
-  if (!dir || !(0, import_node_fs11.existsSync)(dir)) return;
+  if (!dir || !(0, import_node_fs12.existsSync)(dir)) return;
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path11.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path12.delimiter).filter(Boolean);
   if (parts.includes(dir)) {
     env.PATH = current;
     return;
   }
-  env.PATH = [dir, ...parts].join(import_node_path11.delimiter);
+  env.PATH = [dir, ...parts].join(import_node_path12.delimiter);
 }
 function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os5.homedir)()) {
-  return (0, import_node_path11.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
+  return (0, import_node_path12.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
 }
 function isConductorBundledCli(filePath) {
   const p = (filePath ?? "").replace(/\\/g, "/");
@@ -3171,21 +3171,21 @@ function isConductorBundledCli(filePath) {
 function ensureAgentPath(env = process.env) {
   const home = env.HOME || env.USERPROFILE || (0, import_node_os5.homedir)();
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path11.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path12.delimiter).filter(Boolean);
   const seen = new Set(parts);
   const extras = [
-    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path11.join)(home, rel)),
+    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path12.join)(home, rel)),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     // Keep after Homebrew/npm so a user-installed CLI still wins.
     conductorBundledBinDir(home)
   ];
   for (const dir of extras.reverse()) {
-    if (!dir || seen.has(dir) || !(0, import_node_fs11.existsSync)(dir)) continue;
+    if (!dir || seen.has(dir) || !(0, import_node_fs12.existsSync)(dir)) continue;
     parts.unshift(dir);
     seen.add(dir);
   }
-  const next = parts.join(import_node_path11.delimiter);
+  const next = parts.join(import_node_path12.delimiter);
   env.PATH = next;
   return next;
 }
@@ -3199,7 +3199,7 @@ function enrichPathWithNpmGlobalBin(env = process.env) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim().split(/\r?\n/).find(Boolean);
     if (prefix) {
-      const binDir = process.platform === "win32" ? prefix : (0, import_node_path11.join)(prefix, "bin");
+      const binDir = process.platform === "win32" ? prefix : (0, import_node_path12.join)(prefix, "bin");
       prependPathDir(env, binDir);
     }
   } catch {
@@ -3227,14 +3227,14 @@ function withExportedPath(command, pathValue) {
   if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
   return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
 }
-var import_node_fs11, import_node_child_process3, import_node_os5, import_node_path11, EXTRA_BIN_DIRS;
+var import_node_fs12, import_node_child_process3, import_node_os5, import_node_path12, EXTRA_BIN_DIRS;
 var init_path = __esm({
   "src/agents/path.ts"() {
     "use strict";
-    import_node_fs11 = require("fs");
+    import_node_fs12 = require("fs");
     import_node_child_process3 = require("child_process");
     import_node_os5 = require("os");
-    import_node_path11 = require("path");
+    import_node_path12 = require("path");
     EXTRA_BIN_DIRS = [
       ".local/bin",
       ".cargo/bin",
@@ -3426,7 +3426,7 @@ async function warmGithubAgentAuth(opts) {
 }
 function normalizeWritableRoot(raw) {
   const trimmed = raw.trim().replace(/\/+$/, "");
-  return trimmed && (0, import_node_path12.isAbsolute)(trimmed) ? trimmed : null;
+  return trimmed && (0, import_node_path13.isAbsolute)(trimmed) ? trimmed : null;
 }
 async function resolveCodexGitWritableRoots(cwd) {
   const roots = /* @__PURE__ */ new Set();
@@ -3503,11 +3503,11 @@ function formatGitAuthModeDirective(mode) {
       ].join("\n");
   }
 }
-var import_node_path12, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
+var import_node_path13, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
 var init_git_auth_mode = __esm({
   "src/git/git-auth-mode.ts"() {
     "use strict";
-    import_node_path12 = require("path");
+    import_node_path13 = require("path");
     init_app_settings();
     init_github_agent_auth();
     init_run();
@@ -4669,8 +4669,8 @@ function isLocalPrFetchBranch(ref) {
 }
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
-  const worktreePath = (0, import_node_path13.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs12.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path14.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs13.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -4739,8 +4739,8 @@ ${add.stdout}`;
 async function createExistingBranchWorktree(opts) {
   const branchName = opts.branchName.trim();
   if (!branchName) throw new Error("branch name required");
-  const worktreePath = (0, import_node_path13.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs12.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path14.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs13.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -5028,10 +5028,10 @@ function sameRepoPath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
 function listLocalThreadBranchSlugs(repoPath) {
-  const refsDir = (0, import_node_path13.join)(repoPath, ".git", "refs", "heads", "thread");
-  if (!(0, import_node_fs12.existsSync)(refsDir)) return [];
+  const refsDir = (0, import_node_path14.join)(repoPath, ".git", "refs", "heads", "thread");
+  if (!(0, import_node_fs13.existsSync)(refsDir)) return [];
   try {
-    return (0, import_node_fs12.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+    return (0, import_node_fs13.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
     return [];
   }
@@ -5039,8 +5039,8 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if ((0, import_node_fs12.existsSync)(root)) {
-    for (const entry of (0, import_node_fs12.readdirSync)(root, { withFileTypes: true })) {
+  if ((0, import_node_fs13.existsSync)(root)) {
+    for (const entry of (0, import_node_fs13.readdirSync)(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         taken.add(normalizeTakenSlug(entry.name));
       }
@@ -5061,18 +5061,18 @@ function allocateTeamSlug(repoPath) {
   const taken = collectTakenTeamSlugs(repoPath);
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
-    const path2 = (0, import_node_path13.join)(worktreesRoot(repoPath), team.slug);
-    if (!(0, import_node_fs12.existsSync)(path2)) return team;
+    const path2 = (0, import_node_path14.join)(worktreesRoot(repoPath), team.slug);
+    if (!(0, import_node_fs13.existsSync)(path2)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");
 }
-var import_node_fs12, import_node_path13;
+var import_node_fs13, import_node_path14;
 var init_worktree = __esm({
   "src/git/worktree.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
-    import_node_path13 = require("path");
+    import_node_fs13 = require("fs");
+    import_node_path14 = require("path");
     init_paths();
     init_thread_store();
     init_teams();
@@ -5147,7 +5147,7 @@ function coordinatorTurnReminder(opts) {
     goal ? `- Goal / title: ${goal}` : null,
     accountDefaultsPlaybookLine(),
     `- For "what's going on": call list_threads (and list_workspaces if needed). Summarize fleet status \u2014 do not ls/git-status this synthetic home.`,
-    "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn. Commit/push/draft PR with ask_git on the child, then wait_for_turn \u2014 never git/gh from this cwd. Call ask_git merge only if the user explicitly asked to merge.",
+    "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn. If status is error, lastError/text is the failure \u2014 adapt (switch agent, tell the user). Commit/push/draft PR with ask_git on the child, then wait_for_turn \u2014 never git/gh from this cwd. Call ask_git merge only if the user explicitly asked to merge.",
     "- New repo: Bash (clone or gh repo create under ~/sideboard/repos/<name>) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 ask_git create-draft.",
     "- When naming threads for the user, link them as `[Title](sideboard://thread/<id>)`.",
     "- If they will wait on Slack or leave the Mac, call set_caffeinate enabled=true. When they say they are done / wrapping up / going to sleep, call set_caffeinate enabled=false. Closing this chat also turns it off."
@@ -5156,7 +5156,7 @@ function coordinatorTurnReminder(opts) {
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -5164,7 +5164,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs13.readFileSync)((0, import_node_path14.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -5206,9 +5206,9 @@ function ensureGlobalCoordinatorCwd(opts) {
     "Always ask worktree agents to commit, push, and open draft PRs (`ask_git` / `send_to_thread`). Tell them to merge only when the user explicitly asked. The worktree agent runs git/gh; never merge from this orchestration cwd."
   ].join("\n");
   try {
-    (0, import_node_fs13.writeFileSync)((0, import_node_path14.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs14.writeFileSync)((0, import_node_path15.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs13.writeFileSync)((0, import_node_path14.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs14.writeFileSync)((0, import_node_path15.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -5240,12 +5240,12 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs13, import_node_path14, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
+var import_node_fs14, import_node_path15, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs13 = require("fs");
-    import_node_path14 = require("path");
+    import_node_fs14 = require("fs");
+    import_node_path15 = require("path");
     init_worktree();
     init_app_settings();
     init_paths();
@@ -5270,7 +5270,7 @@ var init_coordinator_prompt = __esm({
       "- fork_worktree \u2014 fork a worktree chat into a NEW git worktree + chat (transcript attached); optional agent; leave model unset (Auto) unless you have a reason. Not for orchestration chats.",
       "- fork_chat \u2014 fork a worktree chat (same worktree tab) OR a Global orchestration chat (new orchestration tab); optional agent; leave model unset (Auto) unless you have a reason. Remote coordinators: use this to continue another orchestration chat on a different agent after session limits.",
       "- send_to_thread \u2014 queue a prompt (start/continue a chat turn); pass force_stop: true to interrupt mid-turn / clear stale queued prompts before replacing with a new request",
-      "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply",
+      "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply. On status error, lastError (and text) is the failure \u2014 switch agent, tell the user, or retry; do not treat empty text as success.",
       "- stop_thread \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
       "- archive_thread / restore_thread \u2014 archive (tears down worktree when last tab) or restore",
       "Setup / run:",
@@ -5550,38 +5550,38 @@ __export(workspaces_exports, {
   syncWorkspacesFromThreads: () => syncWorkspacesFromThreads
 });
 function workspacesFile() {
-  return (0, import_node_path15.join)(appDataDir(), "workspaces.json");
+  return (0, import_node_path16.join)(appDataDir(), "workspaces.json");
 }
 function removedWorkspacesFile() {
-  return (0, import_node_path15.join)(appDataDir(), "removed-workspaces.json");
+  return (0, import_node_path16.join)(appDataDir(), "removed-workspaces.json");
 }
 function readAll() {
   const path2 = workspacesFile();
-  if (!(0, import_node_fs14.existsSync)(path2)) return [];
+  if (!(0, import_node_fs15.existsSync)(path2)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs14.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll(list) {
-  (0, import_node_fs14.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs14.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs15.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs15.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path2 = removedWorkspacesFile();
-  if (!(0, import_node_fs14.existsSync)(path2)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs15.existsSync)(path2)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs14.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
     return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 function writeRemoved(paths) {
-  (0, import_node_fs14.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs14.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs15.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs15.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -5604,7 +5604,7 @@ function listWorkspaces() {
 async function addWorkspace(repoPath) {
   const root = await resolveRepoRoot(repoPath);
   if (!root || root === "/") throw new Error(`Invalid repo path: ${repoPath}`);
-  if (!(0, import_node_fs14.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs15.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll();
@@ -5612,7 +5612,7 @@ async function addWorkspace(repoPath) {
   if (existing) return existing;
   const next = {
     path: root,
-    name: (0, import_node_path15.basename)(root),
+    name: (0, import_node_path16.basename)(root),
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeAll([...current, next]);
@@ -5634,10 +5634,10 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path2 || path2 === "/" || isGlobalRepoPath(path2) || byPath.has(path2) || removed.has(path2)) {
       continue;
     }
-    if (!(0, import_node_fs14.existsSync)(path2)) continue;
+    if (!(0, import_node_fs15.existsSync)(path2)) continue;
     const ws = {
       path: path2,
-      name: (0, import_node_path15.basename)(path2),
+      name: (0, import_node_path16.basename)(path2),
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     byPath.set(path2, ws);
@@ -5647,12 +5647,12 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs14, import_node_path15;
+var import_node_fs15, import_node_path16;
 var init_workspaces = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs14 = require("fs");
-    import_node_path15 = require("path");
+    import_node_fs15 = require("fs");
+    import_node_path16 = require("path");
     init_paths();
     init_global_workspace();
     init_worktree();
@@ -5661,32 +5661,32 @@ var init_workspaces = __esm({
 
 // src/brightsy/config.ts
 function brightsyConfigPath() {
-  return (0, import_node_path16.join)((0, import_node_os6.homedir)(), ".brightsy", "config.json");
+  return (0, import_node_path17.join)((0, import_node_os6.homedir)(), ".brightsy", "config.json");
 }
 function loadBrightsyConfig() {
   const path2 = brightsyConfigPath();
-  if (!(0, import_node_fs15.existsSync)(path2)) {
+  if (!(0, import_node_fs16.existsSync)(path2)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
+  const raw = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
   if (!raw.access_token || !raw.account_id) {
     throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
   }
   return raw;
 }
 function saveBrightsyConfig(cfg) {
-  (0, import_node_fs15.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs16.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs15, import_node_os6, import_node_path16;
+var import_node_fs16, import_node_os6, import_node_path17;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
+    import_node_fs16 = require("fs");
     import_node_os6 = require("os");
-    import_node_path16 = require("path");
+    import_node_path17 = require("path");
   }
 });
 
@@ -5789,22 +5789,22 @@ __export(connected_teams_exports, {
   listConnectedBrightsyTeams: () => listConnectedBrightsyTeams
 });
 function storePath() {
-  return (0, import_node_path17.join)(appDataDir(), "brightsy-teams.json");
+  return (0, import_node_path18.join)(appDataDir(), "brightsy-teams.json");
 }
 function readStore() {
   const path2 = storePath();
-  if (!(0, import_node_fs16.existsSync)(path2)) return [];
+  if (!(0, import_node_fs17.existsSync)(path2)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore(teams) {
-  (0, import_node_fs16.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs17.mkdirSync)(appDataDir(), { recursive: true });
   const path2 = storePath();
-  (0, import_node_fs16.writeFileSync)(path2, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs17.writeFileSync)(path2, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -5966,12 +5966,12 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs16, import_node_path17;
+var import_node_fs17, import_node_path18;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.ts"() {
     "use strict";
-    import_node_fs16 = require("fs");
-    import_node_path17 = require("path");
+    import_node_fs17 = require("fs");
+    import_node_path18 = require("path");
     init_paths();
     init_accounts();
     init_config();
@@ -6133,6 +6133,13 @@ function looksLikeMinifiedJsDump(line) {
 function looksLikeNestedElectronCrash(line) {
   return /HasCustomHostObject|ElectronInitializeICUandStartNode/i.test(line);
 }
+function looksLikeHomebrewLibuvCrash(line) {
+  const uvRun = /uv_run/i.test(line);
+  const spin = /SpinEventLoopInternal/i.test(line);
+  const homebrewUv = /Cellar\/libuv|libuv\.\d\.dylib/i.test(line);
+  const homebrewNode = /Cellar\/node\//i.test(line);
+  return uvRun && (homebrewUv || spin || homebrewNode) || spin && (homebrewUv || homebrewNode);
+}
 function clipStderr(text3, maxChars) {
   const trimmed = text3.trim();
   if (trimmed.length <= maxChars) return trimmed;
@@ -6143,6 +6150,7 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   const cursorStartup = [...tail].reverse().find((line) => /cursor startup failed:/i.test(line));
   if (cursorStartup) return clipStderr(cursorStartup, maxChars);
   if (tail.some(looksLikeNestedElectronCrash)) return NESTED_ELECTRON_SUMMARY;
+  if (tail.some(looksLikeHomebrewLibuvCrash)) return HOMEBREW_LIBUV_SUMMARY;
   if (tail.some(
     (line) => /\[resource_exhausted\]|resource_exhausted/i.test(line) || /findFilesWithRipgrep/.test(line)
   )) {
@@ -6165,6 +6173,20 @@ function looksLikeInvalidAgentSession(text3) {
   if (!lower) return false;
   return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower) || /corrupt local agent checkpoint/.test(lower) || /missing root blob/.test(lower) || /\bagent\b.{0,120}\bnot found\b/.test(lower);
 }
+function looksLikeRetryableRunnerCrash(text3) {
+  if (looksLikeAgentFailureMessage(text3)) return false;
+  if (looksLikeInvalidAgentSession(text3)) return false;
+  const lower = text3.trim().toLowerCase();
+  if (/cannot find (?:package|module)|err_module_not_found/.test(lower)) return false;
+  if (!lower) return true;
+  return /uv_run|spineventloopinternal|libuv|homebrew node \+ shared libuv|hascustomhostobject|electroninitializeicuandstartnode|nested chromium|truncated crash dump|sig(?:segv|abrt|ill)|segmentation fault|illegal instruction|fatal error/.test(
+    lower
+  );
+}
+function shouldRetryFailedAgentTurn(detail, opts) {
+  if (looksLikeInvalidAgentSession(detail) && opts.hasSession) return true;
+  return looksLikeRetryableRunnerCrash(detail);
+}
 function looksLikeAgentFailureMessage(text3) {
   const lower = text3.trim().toLowerCase();
   if (!lower) return false;
@@ -6209,11 +6231,22 @@ function humanizeAgentFailDetail(detail) {
   if (/hascustomhostobject|electroninitializeicuandstartnode|nested chromium/i.test(lower)) {
     return `${raw} \u2014 retry the turn; if it keeps failing, pick another agent.`;
   }
+  if (/homebrew node \+ shared libuv|uv_run|spineventloopinternal/i.test(lower)) {
+    return /brew install node@22/i.test(raw) ? raw : `${raw} \u2014 install Node 22 LTS (\`brew install node@22\`) and retry.`;
+  }
   if (/corrupt local agent checkpoint|missing root blob|truncated crash dump/.test(lower)) {
     return `${raw} \u2014 retry the turn (Sideboard will start a fresh Cursor session).`;
   }
   return raw;
 }
+function turnFailChatText(opts) {
+  const chat = opts.assistantText.trim();
+  if (chat) return chat;
+  if (opts.exitCode === 0) return "";
+  const detail = opts.detail.trim();
+  if (detail) return humanizeAgentFailDetail(detail);
+  return formatTurnExitError(opts.exitCode ?? 1, "");
+}
 function formatTurnExitError(exitCode, stderrSummary) {
   const code = exitCode ?? 1;
   const raw = stderrSummary.trim();
@@ -6227,12 +6260,13 @@ function formatTurnExitError(exitCode, stderrSummary) {
   if (looksLikeAgentFailureMessage(raw)) return detail;
   return `exit ${code}: ${detail}`;
 }
-var NODE_VERSION_FOOTER, NESTED_ELECTRON_SUMMARY, MINIFIED_DUMP_SUMMARY;
+var NODE_VERSION_FOOTER, NESTED_ELECTRON_SUMMARY, HOMEBREW_LIBUV_SUMMARY, MINIFIED_DUMP_SUMMARY;
 var init_error_detail = __esm({
   "src/agents/error-detail.ts"() {
     "use strict";
     NODE_VERSION_FOOTER = /^Node\.js v\d+/i;
     NESTED_ELECTRON_SUMMARY = "Cursor local agent crashed at Electron startup (nested Chromium / HasCustomHostObject)";
+    HOMEBREW_LIBUV_SUMMARY = "Cursor runner crashed in Node (Homebrew Node + shared libuv). Install Node 22 LTS (`brew install node@22`) and retry.";
     MINIFIED_DUMP_SUMMARY = "Cursor local agent crashed during startup (truncated crash dump)";
   }
 });
@@ -6521,11 +6555,11 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var import_node_fs17, brightsyAdapter;
+var import_node_fs18, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
-    import_node_fs17 = require("fs");
+    import_node_fs18 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
@@ -6540,7 +6574,7 @@ var init_brightsy = __esm({
       async detect() {
         const brightsy = resolveAgentExecutable("brightsy");
         if (brightsy !== "brightsy") {
-          if (!(0, import_node_fs17.existsSync)(brightsy)) {
+          if (!(0, import_node_fs18.existsSync)(brightsy)) {
             return {
               agent: "brightsy",
               installed: false,
@@ -6673,6 +6707,55 @@ var init_profile = __esm({
   }
 });
 
+// src/agents/packaged-runtime.ts
+function electronResourcesPath() {
+  const resources = process.resourcesPath;
+  if (typeof resources !== "string" || !resources) return null;
+  return resources;
+}
+function packagedCursorRuntimeDir() {
+  const resources = electronResourcesPath();
+  if (!resources) return null;
+  const dir = (0, import_node_path19.join)(resources, "cursor-runtime");
+  if (!(0, import_node_fs19.existsSync)((0, import_node_path19.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
+  return dir;
+}
+function packagedCursorRunnerPath() {
+  const dir = packagedCursorRuntimeDir();
+  return dir ? (0, import_node_path19.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
+}
+function packagedMcpDir() {
+  const resources = electronResourcesPath();
+  if (!resources) return null;
+  const dir = (0, import_node_path19.join)(resources, "sideboard-mcp");
+  if (!(0, import_node_fs19.existsSync)((0, import_node_path19.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
+  return dir;
+}
+function packagedMcpStdioPath() {
+  const dir = packagedMcpDir();
+  return dir ? (0, import_node_path19.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
+}
+function packagedBundledNodePath() {
+  const resources = electronResourcesPath();
+  if (!resources) return null;
+  const bin = (0, import_node_path19.join)(resources, "node", "bin", "node");
+  if (!(0, import_node_fs19.existsSync)(bin)) return null;
+  return bin;
+}
+function packagedCursorRipgrepCandidate(platformPkg, binName) {
+  const dir = packagedCursorRuntimeDir();
+  if (!dir) return null;
+  return (0, import_node_path19.join)(dir, "node_modules", platformPkg, "bin", binName);
+}
+var import_node_fs19, import_node_path19;
+var init_packaged_runtime = __esm({
+  "src/agents/packaged-runtime.ts"() {
+    "use strict";
+    import_node_fs19 = require("fs");
+    import_node_path19 = require("path");
+  }
+});
+
 // src/agents/node-launch.ts
 function isAsarPath(filePath) {
   if (/\.asar\.unpacked([/\\]|$)/.test(filePath)) return false;
@@ -6682,24 +6765,129 @@ function unpackedAsarPath(filePath) {
   if (!isAsarPath(filePath)) return null;
   const unpacked = filePath.replace(/\.asar(?=[/\\])/, ".asar.unpacked");
   if (unpacked === filePath) return null;
-  return (0, import_node_fs18.existsSync)(unpacked) ? unpacked : null;
+  return (0, import_node_fs20.existsSync)(unpacked) ? unpacked : null;
 }
 function nodeReadableScriptPath(scriptPath) {
   return unpackedAsarPath(scriptPath) ?? scriptPath;
 }
-async function findSystemNode() {
-  const whichNode = await run("which", ["node"], { reject: false });
-  const fromWhich = whichNode.exitCode === 0 && whichNode.stdout.trim() ? whichNode.stdout.trim() : "";
-  if (fromWhich && !isElectronLikeCommand(fromWhich)) return fromWhich;
-  const fallbacks = [
-    ...WELL_KNOWN_NODE_BINS,
-    (0, import_node_path18.join)((0, import_node_os7.homedir)(), ".local/share/fnm/aliases/default/bin/node"),
-    (0, import_node_path18.join)((0, import_node_os7.homedir)(), ".nvm/current/bin/node")
+function parseNodeMajor(version) {
+  const match = /^v?(\d+)/.exec(version.trim());
+  if (!match) return null;
+  const major = Number(match[1]);
+  return Number.isInteger(major) ? major : null;
+}
+function scoreNodeForAgentRuntime(candidate) {
+  const major = parseNodeMajor(candidate.version);
+  if (major == null) return Number.NEGATIVE_INFINITY;
+  if (major < 20) return major - 100;
+  const posix = candidate.path.replace(/\\/g, "/");
+  let score = 0;
+  if (major % 2 === 0) {
+    score += 1e3 + major * 10;
+  } else {
+    score += major;
+  }
+  if (/\/Cellar\/node\/\d/.test(posix) && !/\/Cellar\/node@\d+/.test(posix)) {
+    score -= 50;
+  }
+  return score;
+}
+function pickPreferredNode(candidates) {
+  let best = null;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  for (const candidate of candidates) {
+    const score = scoreNodeForAgentRuntime(candidate);
+    if (score > bestScore) {
+      bestScore = score;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function versionDirNodeBins(root, toBin) {
+  if (!(0, import_node_fs20.existsSync)(root)) return [];
+  try {
+    return (0, import_node_fs20.readdirSync)(root).map(toBin);
+  } catch {
+    return [];
+  }
+}
+function defaultNodeBinCandidates(home = (0, import_node_os7.homedir)()) {
+  const kegs = ["/opt/homebrew", "/usr/local"].flatMap(
+    (prefix) => PREFERRED_LTS_MAJORS.map((major) => (0, import_node_path20.join)(prefix, "opt", `node@${major}`, "bin", "node"))
+  );
+  return [
+    ...kegs,
+    "/opt/homebrew/bin/node",
+    "/usr/local/bin/node",
+    (0, import_node_path20.join)(home, ".local/share/fnm/aliases/default/bin/node"),
+    (0, import_node_path20.join)(home, ".nvm/current/bin/node"),
+    (0, import_node_path20.join)(home, ".volta/bin/node"),
+    (0, import_node_path20.join)(home, ".asdf/shims/node"),
+    (0, import_node_path20.join)(home, ".local/share/mise/shims/node"),
+    ...versionDirNodeBins(
+      (0, import_node_path20.join)(home, ".nvm", "versions", "node"),
+      (name) => (0, import_node_path20.join)(home, ".nvm", "versions", "node", name, "bin", "node")
+    ),
+    ...versionDirNodeBins(
+      (0, import_node_path20.join)(home, ".local/share/fnm", "node-versions"),
+      (name) => (0, import_node_path20.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
+    ),
+    ...versionDirNodeBins(
+      (0, import_node_path20.join)(home, ".volta", "tools", "image", "node"),
+      (name) => (0, import_node_path20.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
+    )
   ];
-  for (const bin of fallbacks) {
-    if ((0, import_node_fs18.existsSync)(bin) && !isElectronLikeCommand(bin)) return bin;
+}
+function uniqueExistingNodeBins(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of paths) {
+    const p = raw.trim();
+    if (!p || !(0, import_node_fs20.existsSync)(p) || isElectronLikeCommand(p)) continue;
+    let key = p;
+    try {
+      key = (0, import_node_fs20.realpathSync)(p);
+    } catch {
+      continue;
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(p);
   }
-  return null;
+  return out;
+}
+async function whichAllNode() {
+  if (process.platform === "win32") {
+    const located = await run("where", ["node"], { reject: false, timeoutMs: 5e3 });
+    if (located.exitCode !== 0) return [];
+    return located.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  }
+  const all = await run("which", ["-a", "node"], { reject: false, timeoutMs: 5e3 });
+  if (all.exitCode === 0 && all.stdout.trim()) {
+    return all.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  }
+  const single = await run("which", ["node"], { reject: false, timeoutMs: 5e3 });
+  if (single.exitCode !== 0 || !single.stdout.trim()) return [];
+  return [single.stdout.trim()];
+}
+async function probeNodeVersion(bin) {
+  const probed = await run(bin, ["-v"], { reject: false, timeoutMs: 4e3 });
+  if (probed.exitCode !== 0) return null;
+  const version = probed.stdout.trim().split(/\r?\n/).find(Boolean);
+  return version || null;
+}
+async function findSystemNode() {
+  const fromPath = await whichAllNode();
+  const bins = uniqueExistingNodeBins([...fromPath, ...defaultNodeBinCandidates()]);
+  if (bins.length === 0) return null;
+  const probed = await Promise.all(
+    bins.map(async (path2) => {
+      const version = await probeNodeVersion(path2);
+      return version ? { path: path2, version } : null;
+    })
+  );
+  return pickPreferredNode(probed.filter((c) => c != null));
 }
 function applyNodeLaunch(launch, args) {
   const readableArgs = args.map(nodeReadableScriptPath);
@@ -6717,9 +6905,13 @@ function applyNodeLaunch(launch, args) {
 async function resolveNodeLaunch(scriptPath) {
   const script = nodeReadableScriptPath(scriptPath);
   if (!isAsarPath(script)) {
-    const nodeBin = await findSystemNode();
-    if (nodeBin) {
-      return { file: nodeBin, env: {} };
+    const bundled = packagedBundledNodePath();
+    if (bundled && !isElectronLikeCommand(bundled)) {
+      return { file: bundled, env: {} };
+    }
+    const node = await findSystemNode();
+    if (node) {
+      return { file: node.path, env: {}, nodeVersion: node.version };
     }
   }
   return {
@@ -6727,61 +6919,17 @@ async function resolveNodeLaunch(scriptPath) {
     env: { ELECTRON_RUN_AS_NODE: "1" }
   };
 }
-var import_node_fs18, import_node_os7, import_node_path18, WELL_KNOWN_NODE_BINS;
+var import_node_fs20, import_node_os7, import_node_path20, PREFERRED_LTS_MAJORS;
 var init_node_launch = __esm({
   "src/agents/node-launch.ts"() {
     "use strict";
-    import_node_fs18 = require("fs");
+    import_node_fs20 = require("fs");
     import_node_os7 = require("os");
-    import_node_path18 = require("path");
+    import_node_path20 = require("path");
     init_nested_electron_env();
     init_run();
-    WELL_KNOWN_NODE_BINS = [
-      "/opt/homebrew/bin/node",
-      "/usr/local/bin/node"
-    ];
-  }
-});
-
-// src/agents/packaged-runtime.ts
-function electronResourcesPath() {
-  const resources = process.resourcesPath;
-  if (typeof resources !== "string" || !resources) return null;
-  return resources;
-}
-function packagedCursorRuntimeDir() {
-  const resources = electronResourcesPath();
-  if (!resources) return null;
-  const dir = (0, import_node_path19.join)(resources, "cursor-runtime");
-  if (!(0, import_node_fs19.existsSync)((0, import_node_path19.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
-  return dir;
-}
-function packagedCursorRunnerPath() {
-  const dir = packagedCursorRuntimeDir();
-  return dir ? (0, import_node_path19.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
-}
-function packagedMcpDir() {
-  const resources = electronResourcesPath();
-  if (!resources) return null;
-  const dir = (0, import_node_path19.join)(resources, "sideboard-mcp");
-  if (!(0, import_node_fs19.existsSync)((0, import_node_path19.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
-  return dir;
-}
-function packagedMcpStdioPath() {
-  const dir = packagedMcpDir();
-  return dir ? (0, import_node_path19.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
-}
-function packagedCursorRipgrepCandidate(platformPkg, binName) {
-  const dir = packagedCursorRuntimeDir();
-  if (!dir) return null;
-  return (0, import_node_path19.join)(dir, "node_modules", platformPkg, "bin", binName);
-}
-var import_node_fs19, import_node_path19;
-var init_packaged_runtime = __esm({
-  "src/agents/packaged-runtime.ts"() {
-    "use strict";
-    import_node_fs19 = require("fs");
-    import_node_path19 = require("path");
+    init_packaged_runtime();
+    PREFERRED_LTS_MAJORS = [24, 22, 20];
   }
 });
 
@@ -6868,37 +7016,37 @@ function corePackageDir() {
   try {
     const url = import_meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path20.dirname)((0, import_node_url.fileURLToPath)(url));
+      return (0, import_node_path21.dirname)((0, import_node_url.fileURLToPath)(url));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path20.join)(process.cwd(), "package.json"));
-    return (0, import_node_path20.dirname)(req.resolve("@sideboard-ai/core"));
+    const req = (0, import_node_module.createRequire)((0, import_node_path21.join)(process.cwd(), "package.json"));
+    return (0, import_node_path21.dirname)(req.resolve("@sideboard-ai/core"));
   } catch {
     return process.cwd();
   }
 }
 function findSideboardMcpJsEntry() {
   const override = process.env.SIDEBOARD_MCP_ENTRY?.trim() || process.env.SIDEBOARD_CLI?.trim();
-  if (override && (0, import_node_fs20.existsSync)(override)) return override;
+  if (override && (0, import_node_fs21.existsSync)(override)) return override;
   const packaged = packagedMcpStdioPath();
   if (packaged) return packaged;
   let dir = corePackageDir();
   for (let i = 0; i < 10; i++) {
     const candidates = [
-      (0, import_node_path20.join)(dir, "mcp/run-stdio.js"),
-      (0, import_node_path20.join)(dir, "mcp/run-stdio.cjs"),
-      (0, import_node_path20.join)(dir, "dist/mcp/run-stdio.js"),
-      (0, import_node_path20.join)(dir, "dist/mcp/run-stdio.cjs"),
-      (0, import_node_path20.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
-      (0, import_node_path20.join)(dir, "packages/cli/dist/index.js"),
-      (0, import_node_path20.join)(dir, "cli/dist/index.js")
+      (0, import_node_path21.join)(dir, "mcp/run-stdio.js"),
+      (0, import_node_path21.join)(dir, "mcp/run-stdio.cjs"),
+      (0, import_node_path21.join)(dir, "dist/mcp/run-stdio.js"),
+      (0, import_node_path21.join)(dir, "dist/mcp/run-stdio.cjs"),
+      (0, import_node_path21.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
+      (0, import_node_path21.join)(dir, "packages/cli/dist/index.js"),
+      (0, import_node_path21.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs20.existsSync)(p) && !isAsarPath(p)) return p;
+      if ((0, import_node_fs21.existsSync)(p) && !isAsarPath(p)) return p;
     }
-    const parent = (0, import_node_path20.dirname)(dir);
+    const parent = (0, import_node_path21.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -7039,22 +7187,22 @@ function writeMcpServersConfig(servers) {
       ...env ? { env } : {}
     };
   }
-  const dir = (0, import_node_fs20.mkdtempSync)((0, import_node_path20.join)((0, import_node_os8.tmpdir)(), "sideboard-mcp-"));
-  const cfgPath = (0, import_node_path20.join)(dir, "mcp.json");
-  (0, import_node_fs20.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  const dir = (0, import_node_fs21.mkdtempSync)((0, import_node_path21.join)((0, import_node_os8.tmpdir)(), "sideboard-mcp-"));
+  const cfgPath = (0, import_node_path21.join)(dir, "mcp.json");
+  (0, import_node_fs21.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
 async function writeInjectedMcpConfig(opts) {
   return writeMcpServersConfig(await buildInjectedMcpServers(opts));
 }
-var import_node_fs20, import_node_module, import_node_os8, import_node_path20, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, BRIGHTSY_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
+var import_node_fs21, import_node_module, import_node_os8, import_node_path21, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, BRIGHTSY_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
 var init_injected_mcp = __esm({
   "src/agents/injected-mcp.ts"() {
     "use strict";
-    import_node_fs20 = require("fs");
+    import_node_fs21 = require("fs");
     import_node_module = require("module");
     import_node_os8 = require("os");
-    import_node_path20 = require("path");
+    import_node_path21 = require("path");
     import_node_url = require("url");
     init_run();
     init_config();
@@ -7247,11 +7395,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs21, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs22, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs21 = require("fs");
+    import_node_fs22 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -7280,7 +7428,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs21.existsSync)(claude)) {
+          if (!(0, import_node_fs22.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -7517,7 +7665,7 @@ async function listCodexModels() {
   if (codex === "codex") {
     const which = await run("which", ["codex"], { reject: false });
     if (which.exitCode !== 0) return FALLBACK_CODEX_MODELS;
-  } else if (!(0, import_node_fs22.existsSync)(codex)) {
+  } else if (!(0, import_node_fs23.existsSync)(codex)) {
     return FALLBACK_CODEX_MODELS;
   }
   const listed = await run(codex, ["debug", "models"], { reject: false });
@@ -7552,12 +7700,12 @@ function usageFromCodex(usage) {
 }
 function codexConfigHasNetworkAccess() {
   const candidates = [
-    (0, import_node_path21.join)((0, import_node_os9.homedir)(), ".codex", "config.toml"),
-    (0, import_node_path21.join)((0, import_node_os9.homedir)(), ".config", "codex", "config.toml")
+    (0, import_node_path22.join)((0, import_node_os9.homedir)(), ".codex", "config.toml"),
+    (0, import_node_path22.join)((0, import_node_os9.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path2 of candidates) {
-    if (!(0, import_node_fs22.existsSync)(path2)) continue;
-    const text3 = (0, import_node_fs22.readFileSync)(path2, "utf8");
+    if (!(0, import_node_fs23.existsSync)(path2)) continue;
+    const text3 = (0, import_node_fs23.readFileSync)(path2, "utf8");
     if (/network_access\s*=\s*true/.test(text3)) return true;
   }
   return false;
@@ -7589,21 +7737,21 @@ function asRecord(value) {
   return void 0;
 }
 function codexLooksAuthenticated() {
-  const authPath = (0, import_node_path21.join)((0, import_node_os9.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs22.existsSync)(authPath)) return false;
+  const authPath = (0, import_node_path22.join)((0, import_node_os9.homedir)(), ".codex", "auth.json");
+  if (!(0, import_node_fs23.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs22.statSync)(authPath).size > 2;
+    return (0, import_node_fs23.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs22, import_node_os9, import_node_path21, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs23, import_node_os9, import_node_path22, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
 var init_codex = __esm({
   "src/agents/codex.ts"() {
     "use strict";
-    import_node_fs22 = require("fs");
+    import_node_fs23 = require("fs");
     import_node_os9 = require("os");
-    import_node_path21 = require("path");
+    import_node_path22 = require("path");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -7628,7 +7776,7 @@ var init_codex = __esm({
       async detect() {
         const codex = resolveAgentExecutable("codex");
         if (codex !== "codex") {
-          if (!(0, import_node_fs22.existsSync)(codex)) {
+          if (!(0, import_node_fs23.existsSync)(codex)) {
             return {
               agent: "codex",
               installed: false,
@@ -8037,21 +8185,21 @@ function platformRipgrepPackage() {
 }
 function usableRipgrepPath(candidate) {
   const raw = candidate?.trim();
-  if (!raw || !(0, import_node_path22.isAbsolute)(raw)) return null;
+  if (!raw || !(0, import_node_path23.isAbsolute)(raw)) return null;
   const readable = nodeReadableScriptPath(raw);
-  if (!(0, import_node_fs23.existsSync)(readable) || isAsarPath(readable)) return null;
+  if (!(0, import_node_fs24.existsSync)(readable) || isAsarPath(readable)) return null;
   return readable;
 }
 function walkForBundledRipgrep(startFile) {
   if (!startFile) return null;
   const pkg = platformRipgrepPackage();
   const name = rgBinaryName();
-  let dir = (0, import_node_path22.dirname)((0, import_node_path22.resolve)(startFile));
-  const root = (0, import_node_path22.parse)(dir).root;
+  let dir = (0, import_node_path23.dirname)((0, import_node_path23.resolve)(startFile));
+  const root = (0, import_node_path23.parse)(dir).root;
   while (dir !== root) {
-    const hit = usableRipgrepPath((0, import_node_path22.join)(dir, "node_modules", pkg, "bin", name));
+    const hit = usableRipgrepPath((0, import_node_path23.join)(dir, "node_modules", pkg, "bin", name));
     if (hit) return hit;
-    const next = (0, import_node_path22.dirname)(dir);
+    const next = (0, import_node_path23.dirname)(dir);
     if (next === dir) break;
     dir = next;
   }
@@ -8061,7 +8209,7 @@ function requireResolveBundledRipgrep(fromFile) {
   try {
     const req = (0, import_node_module2.createRequire)(fromFile);
     const pkgJson = req.resolve(`${platformRipgrepPackage()}/package.json`);
-    return usableRipgrepPath((0, import_node_path22.join)((0, import_node_path22.dirname)(pkgJson), "bin", rgBinaryName()));
+    return usableRipgrepPath((0, import_node_path23.join)((0, import_node_path23.dirname)(pkgJson), "bin", rgBinaryName()));
   } catch {
     return null;
   }
@@ -8081,13 +8229,13 @@ function cursorRipgrepEnv(opts) {
   const path2 = resolveCursorRipgrepPath(opts);
   return path2 ? { [RIPGREP_ENV]: path2 } : {};
 }
-var import_node_fs23, import_node_module2, import_node_path22, import_node_url2, import_meta2, RIPGREP_ENV;
+var import_node_fs24, import_node_module2, import_node_path23, import_node_url2, import_meta2, RIPGREP_ENV;
 var init_cursor_ripgrep = __esm({
   "src/agents/cursor-ripgrep.ts"() {
     "use strict";
-    import_node_fs23 = require("fs");
+    import_node_fs24 = require("fs");
     import_node_module2 = require("module");
-    import_node_path22 = require("path");
+    import_node_path23 = require("path");
     import_node_url2 = require("url");
     init_node_launch();
     init_packaged_runtime();
@@ -8135,11 +8283,11 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path23.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
+    return (0, import_node_path24.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
   } catch {
     try {
       const req = (0, import_node_module3.createRequire)(process.cwd() + "/");
-      return (0, import_node_path23.dirname)(req.resolve("@sideboard-ai/core"));
+      return (0, import_node_path24.dirname)(req.resolve("@sideboard-ai/core"));
     } catch {
       return process.cwd();
     }
@@ -8150,27 +8298,27 @@ function cursorRunnerPath() {
   if (packaged) return packaged;
   const root = entryDir();
   const candidates = [
-    (0, import_node_path23.join)(root, "agents", "cursor-runner.js"),
-    (0, import_node_path23.join)(root, "agents", "cursor-runner.cjs"),
+    (0, import_node_path24.join)(root, "agents", "cursor-runner.js"),
+    (0, import_node_path24.join)(root, "agents", "cursor-runner.cjs"),
     // If somehow resolved from package root instead of dist/
-    (0, import_node_path23.join)(root, "dist", "agents", "cursor-runner.js"),
-    (0, import_node_path23.join)(root, "dist", "agents", "cursor-runner.cjs"),
+    (0, import_node_path24.join)(root, "dist", "agents", "cursor-runner.js"),
+    (0, import_node_path24.join)(root, "dist", "agents", "cursor-runner.cjs"),
     // Source tree (dev): packages/core/src/agents/cursor-runner.ts
-    (0, import_node_path23.join)(root, "cursor-runner.ts"),
-    (0, import_node_path23.join)(root, "src", "agents", "cursor-runner.ts")
+    (0, import_node_path24.join)(root, "cursor-runner.ts"),
+    (0, import_node_path24.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs24.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs25.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs24, import_node_module3, import_node_path23, import_node_url3, import_sdk, import_meta3, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs25, import_node_module3, import_node_path24, import_node_url3, import_sdk, import_meta3, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
 var init_cursor = __esm({
   "src/agents/cursor.ts"() {
     "use strict";
-    import_node_fs24 = require("fs");
+    import_node_fs25 = require("fs");
     import_node_module3 = require("module");
-    import_node_path23 = require("path");
+    import_node_path24 = require("path");
     import_node_url3 = require("url");
     import_sdk = require("@cursor/sdk");
     init_run();
@@ -8302,7 +8450,7 @@ async function listOpencodeModels() {
   if (opencode === "opencode") {
     const which = await run("which", ["opencode"], { reject: false });
     if (which.exitCode !== 0) return FALLBACK_OPENCODE_MODELS;
-  } else if (!(0, import_node_fs25.existsSync)(opencode)) {
+  } else if (!(0, import_node_fs26.existsSync)(opencode)) {
     return FALLBACK_OPENCODE_MODELS;
   }
   const listed = await run(opencode, ["models"], { reject: false });
@@ -8332,11 +8480,11 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var import_node_fs25, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs26, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
-    import_node_fs25 = require("fs");
+    import_node_fs26 = require("fs");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -8362,7 +8510,7 @@ var init_opencode = __esm({
       async detect() {
         const opencode = resolveAgentExecutable("opencode");
         if (opencode !== "opencode") {
-          if (!(0, import_node_fs25.existsSync)(opencode)) {
+          if (!(0, import_node_fs26.existsSync)(opencode)) {
             return {
               agent: "opencode",
               installed: false,
@@ -9159,40 +9307,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore2(worktreePath) {
-  const gitignoreAbs = (0, import_node_path36.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs39.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs39.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path37.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs40.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs40.mkdirSync)((0, import_node_path37.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs40.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path36.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path37.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs39.existsSync)(abs)) return null;
+  if (!(0, import_node_fs40.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs39.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs40.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path36.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path36.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path37.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path37.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore2(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(abs), { recursive: true });
+  (0, import_node_fs40.mkdirSync)((0, import_node_path37.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs39.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs40.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs39, import_node_path36;
+var import_node_fs40, import_node_path37;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs39 = require("fs");
-    import_node_path36 = require("path");
+    import_node_fs40 = require("fs");
+    import_node_path37 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -9207,10 +9355,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path37.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs40.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path38.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs41.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs40.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs41.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -9236,12 +9384,12 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs40, import_node_path37;
+var import_node_fs41, import_node_path38;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs40 = require("fs");
-    import_node_path37 = require("path");
+    import_node_fs41 = require("fs");
+    import_node_path38 = require("path");
     init_paths();
   }
 });
@@ -9388,6 +9536,7 @@ __export(index_exports, {
   captureTurnBaseline: () => captureTurnBaseline,
   checkoutPrStackLayer: () => checkoutPrStackLayer,
   childEnvWithAppSettings: () => childEnvWithAppSettings,
+  claimDesktopHost: () => claimDesktopHost,
   claudeAdapter: () => claudeAdapter,
   claudeChromeEnabled: () => claudeChromeEnabled,
   claudeUserSettingsPath: () => claudeUserSettingsPath,
@@ -9426,6 +9575,7 @@ __export(index_exports, {
   decodeBrightsyTarget: () => decodeBrightsyTarget,
   deleteBranchOnPurgeEnabled: () => deleteBranchOnPurgeEnabled,
   deleteThreadRecord: () => deleteThreadRecord,
+  desktopHostPidPath: () => desktopHostPidPath,
   detectAgents: () => detectAgents,
   detectGhStack: () => detectGhStack,
   detectLocalMergeConflicts: () => detectLocalMergeConflicts,
@@ -9551,6 +9701,7 @@ __export(index_exports, {
   isConductorBundledCli: () => isConductorBundledCli,
   isCursorAutoModel: () => isCursorAutoModel,
   isDefaultishSourceRef: () => isDefaultishSourceRef,
+  isDesktopHostAlive: () => isDesktopHostAlive,
   isDirty: () => isDirty,
   isGhRateLimitError: () => isGhRateLimitError,
   isGlobalRepoPath: () => isGlobalRepoPath,
@@ -9572,6 +9723,7 @@ __export(index_exports, {
   isSlackExternalReplyPrompt: () => isSlackExternalReplyPrompt,
   isSlackOAuthCancelled: () => isSlackOAuthCancelled,
   isThinkingEffort: () => isThinkingEffort,
+  isThisProcessDesktopHost: () => isThisProcessDesktopHost,
   isThreadCaffeinated: () => isThreadCaffeinated,
   isWorkspaceScratchPath: () => isWorkspaceScratchPath,
   linearAuthorizationHeader: () => linearAuthorizationHeader,
@@ -9673,6 +9825,7 @@ __export(index_exports, {
   refreshSlackReplyBadges: () => refreshSlackReplyBadges,
   registerPackagedUserMcpClients: () => registerPackagedUserMcpClients,
   releaseCaffeinateHoldForThread: () => releaseCaffeinateHoldForThread,
+  releaseDesktopHost: () => releaseDesktopHost,
   removeWorkspace: () => removeWorkspace,
   removeWorktree: () => removeWorktree,
   repoSlug: () => repoSlug,
@@ -9773,6 +9926,7 @@ __export(index_exports, {
   taskMessageText: () => taskMessageText,
   thinkingEffortBars: () => thinkingEffortBars,
   thinkingEffortLabel: () => thinkingEffortLabel,
+  thisProcessShouldDrainAgentQueues: () => thisProcessShouldDrainAgentQueues,
   threadDisplayLabel: () => threadDisplayLabel,
   threadFilePath: () => threadFilePath,
   threadLockPath: () => threadLockPath,
@@ -9820,6 +9974,55 @@ init_app_settings();
 init_caffeinate_hold();
 init_secure_file();
 init_thread_store();
+
+// src/store/desktop-host.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
+init_paths();
+function desktopHostPidPath() {
+  return (0, import_node_path10.join)(appDataDir(), "desktop-host.pid");
+}
+function claimDesktopHost(pid = process.pid) {
+  (0, import_node_fs10.writeFileSync)(desktopHostPidPath(), `${pid}
+`, "utf8");
+}
+function releaseDesktopHost(pid = process.pid) {
+  if (readDesktopHostPid() !== pid) return;
+  try {
+    (0, import_node_fs10.unlinkSync)(desktopHostPidPath());
+  } catch {
+  }
+}
+function readDesktopHostPid() {
+  try {
+    const pid = Number.parseInt((0, import_node_fs10.readFileSync)(desktopHostPidPath(), "utf8").trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    return pid;
+  } catch {
+    return null;
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDesktopHostAlive() {
+  const pid = readDesktopHostPid();
+  return pid != null && pidAlive(pid);
+}
+function isThisProcessDesktopHost() {
+  return readDesktopHostPid() === process.pid && pidAlive(process.pid);
+}
+function thisProcessShouldDrainAgentQueues() {
+  if (isThisProcessDesktopHost()) return true;
+  return !isDesktopHostAlive();
+}
+
+// src/index.ts
 init_workspaces();
 init_global_workspace();
 init_run();
@@ -10979,8 +11182,8 @@ init_usage();
 init_claude_mcp();
 
 // src/agents/instructions.ts
-var import_node_fs26 = require("fs");
-var import_node_path24 = require("path");
+var import_node_fs27 = require("fs");
+var import_node_path25 = require("path");
 init_git_auth_mode();
 init_worktree_labels();
 function normPath3(p) {
@@ -11151,11 +11354,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seenPaths.has(rel)) continue;
-    const abs = (0, import_node_path24.join)(worktreePath, rel);
-    if (!(0, import_node_fs26.existsSync)(abs)) continue;
+    const abs = (0, import_node_path25.join)(worktreePath, rel);
+    if (!(0, import_node_fs27.existsSync)(abs)) continue;
     try {
-      if (!(0, import_node_fs26.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs26.readFileSync)(abs, "utf8");
+      if (!(0, import_node_fs27.statSync)(abs).isFile()) continue;
+      let content = (0, import_node_fs27.readFileSync)(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -11237,9 +11440,9 @@ async function requireAgent(agent, opts) {
 init_settings();
 
 // src/hook/conductor.ts
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 var import_node_net = require("net");
-var import_node_path25 = require("path");
+var import_node_path26 = require("path");
 var import_execa4 = require("execa");
 var import_node_readline3 = require("readline");
 init_settings();
@@ -11254,9 +11457,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path2 = (0, import_node_path25.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs27.existsSync)(path2)) return [];
-  return (0, import_node_fs27.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path2 = (0, import_node_path26.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs28.existsSync)(path2)) return [];
+  return (0, import_node_fs28.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -11266,10 +11469,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs27.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs28.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path25.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path26.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -11281,7 +11484,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs27.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs28.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -11295,11 +11498,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path25.join)(repoPath, rel);
-    if (!(0, import_node_fs27.existsSync)(src)) continue;
-    const dest = (0, import_node_path25.join)(worktreePath, rel);
-    (0, import_node_fs27.mkdirSync)((0, import_node_path25.dirname)(dest), { recursive: true });
-    (0, import_node_fs27.copyFileSync)(src, dest);
+    const src = (0, import_node_path26.join)(repoPath, rel);
+    if (!(0, import_node_fs28.existsSync)(src)) continue;
+    const dest = (0, import_node_path26.join)(worktreePath, rel);
+    (0, import_node_fs28.mkdirSync)((0, import_node_path26.dirname)(dest), { recursive: true });
+    (0, import_node_fs28.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -11335,7 +11538,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path25.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path26.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -11596,12 +11799,12 @@ init_convention_setup();
 init_cursor_worktrees();
 
 // src/diff/diff.ts
-var import_node_fs28 = require("fs");
-var import_node_path26 = require("path");
+var import_node_fs29 = require("fs");
+var import_node_path27 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs28.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs29.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -11609,7 +11812,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs28.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs29.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -11745,11 +11948,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path26.join)(worktreePath, path2);
+  const abs = (0, import_node_path27.join)(worktreePath, path2);
   try {
-    const st = (0, import_node_fs28.statSync)(abs);
+    const st = (0, import_node_fs29.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs28.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs29.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -12250,8 +12453,8 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path26.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs28.statSync)(abs);
+  const abs = (0, import_node_path27.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs29.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -12260,7 +12463,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs28.readFileSync)(abs);
+  const buf = (0, import_node_fs29.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -12270,12 +12473,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path26.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs28.statSync)(abs);
+  const abs = (0, import_node_path27.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs29.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs28.readFileSync)(abs);
+  const buf = (0, import_node_fs29.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -12318,9 +12521,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path26.join)(worktreePath, relativePath);
-  (0, import_node_fs28.mkdirSync)((0, import_node_path26.dirname)(abs), { recursive: true });
-  (0, import_node_fs28.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path27.join)(worktreePath, relativePath);
+  (0, import_node_fs29.mkdirSync)((0, import_node_path27.dirname)(abs), { recursive: true });
+  (0, import_node_fs29.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -12339,9 +12542,9 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs29 = require("fs");
+var import_node_fs30 = require("fs");
 var import_node_os10 = require("os");
-var import_node_path27 = require("path");
+var import_node_path28 = require("path");
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -12373,7 +12576,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs29.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs30.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -12392,19 +12595,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs29.existsSync)(dir)) return;
+  if (!(0, import_node_fs30.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs29.readdirSync)(dir);
+    entries = (0, import_node_fs30.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path27.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs29.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path28.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs30.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs29.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs30.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -12413,24 +12616,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs29.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs30.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs29.readdirSync)(dir);
+      entries = (0, import_node_fs30.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path27.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path28.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path27.join)(dir, entry);
+      const full = (0, import_node_path28.join)(dir, entry);
       try {
-        if (!(0, import_node_fs29.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs30.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -12448,17 +12651,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os10.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path27.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path28.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path27.join)(home, ".claude/skills"),
-    (0, import_node_path27.join)(home, ".cursor/skills"),
-    (0, import_node_path27.join)(home, ".sideboard/skills"),
-    (0, import_node_path27.join)(home, ".brightsy/skills")
+    (0, import_node_path28.join)(home, ".claude/skills"),
+    (0, import_node_path28.join)(home, ".cursor/skills"),
+    (0, import_node_path28.join)(home, ".sideboard/skills"),
+    (0, import_node_path28.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path27.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path28.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -12470,7 +12673,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = (0, import_node_fs29.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs30.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -12611,8 +12814,8 @@ function buildDiffCommentAttachment(input) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs30 = require("fs");
-var import_node_path28 = require("path");
+var import_node_fs31 = require("fs");
+var import_node_path29 = require("path");
 var import_node_crypto5 = require("crypto");
 init_workspace_scratch();
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -12638,7 +12841,7 @@ var IMAGE_MIME_BY_EXT = {
 var MAX_INLINE_BYTES = 4e5;
 var MAX_PREVIEW_BYTES = 5e6;
 function fileExtension(filePath) {
-  const base = (0, import_node_path28.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path29.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -12648,22 +12851,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path28.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs30.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path28.join)(dir, ".gitignore");
-  if (!(0, import_node_fs30.existsSync)(gi)) {
-    (0, import_node_fs30.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  const dir = (0, import_node_path29.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs31.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path29.join)(dir, ".gitignore");
+  if (!(0, import_node_fs31.existsSync)(gi)) {
+    (0, import_node_fs31.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs30.existsSync)((0, import_node_path28.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path28.extname)(safe);
+  if (!(0, import_node_fs31.existsSync)((0, import_node_path29.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path29.extname)(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!(0, import_node_fs30.existsSync)((0, import_node_path28.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs31.existsSync)((0, import_node_path29.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
@@ -12715,9 +12918,9 @@ function attachmentFromBuffer(name, buf, opts) {
   };
 }
 function attachmentFromAbsolutePath(absolutePath) {
-  const name = (0, import_node_path28.basename)(absolutePath);
+  const name = (0, import_node_path29.basename)(absolutePath);
   try {
-    const st = (0, import_node_fs30.statSync)(absolutePath);
+    const st = (0, import_node_fs31.statSync)(absolutePath);
     if (!st.isFile()) {
       return {
         id: (0, import_node_crypto5.randomUUID)(),
@@ -12726,7 +12929,7 @@ function attachmentFromAbsolutePath(absolutePath) {
         content: `(not a file: ${absolutePath})`
       };
     }
-    const buf = (0, import_node_fs30.readFileSync)(absolutePath);
+    const buf = (0, import_node_fs31.readFileSync)(absolutePath);
     return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
   } catch (err) {
     return {
@@ -12742,15 +12945,15 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path28.basename)(abs);
+    const originalName = (0, import_node_path29.basename)(abs);
     try {
-      const st = (0, import_node_fs30.statSync)(abs);
+      const st = (0, import_node_fs31.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path28.join)(dir, name);
-      (0, import_node_fs30.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path29.join)(dir, name);
+      (0, import_node_fs31.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs30.readFileSync)(destAbs);
+      const buf = (0, import_node_fs31.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -12772,8 +12975,8 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path28.join)(dir, name);
-      (0, import_node_fs30.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path29.join)(dir, name);
+      (0, import_node_fs31.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -12809,18 +13012,18 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
         id: (0, import_node_crypto5.randomUUID)(),
-        name: (0, import_node_path28.basename)(rel) || "file",
+        name: (0, import_node_path29.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path28.basename)(rel);
+    const name = (0, import_node_path29.basename)(rel);
     try {
-      const abs = (0, import_node_path28.join)(worktreePath, rel);
-      const st = (0, import_node_fs30.statSync)(abs);
+      const abs = (0, import_node_path29.join)(worktreePath, rel);
+      const st = (0, import_node_fs31.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs30.readFileSync)(abs);
+      const buf = (0, import_node_fs31.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13308,7 +13511,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/threads/create.ts
-var import_node_fs31 = require("fs");
+var import_node_fs32 = require("fs");
 init_worktree();
 init_app_settings();
 init_thread_store();
@@ -13322,7 +13525,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs31.existsSync)(repoPath)) {
+  if (!(0, import_node_fs32.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -13562,7 +13765,7 @@ async function forkThreadWorktree(input, onSetupLine) {
 }
 
 // src/threads/stack-layers.ts
-var import_node_fs32 = require("fs");
+var import_node_fs33 = require("fs");
 init_run();
 init_stack();
 init_worktree();
@@ -13630,7 +13833,7 @@ async function openStackLayer(input, _onSetupLine) {
   let createdWorktree = false;
   const trees = await listWorktrees(repoPath);
   const checkedOut = trees.find((w) => w.branch === branchName);
-  if (checkedOut?.path && (0, import_node_fs32.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs33.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -13772,7 +13975,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs32.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs33.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
   if (!input.branches.length) throw new Error("At least one branch name required");
   const status = await detectGhStack(repoPath);
   if (!status.available) throw new Error(status.reason);
@@ -13839,7 +14042,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs32.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs33.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -13862,21 +14065,21 @@ function stackAgentDefaultsFrom(input) {
 
 // src/threads/adopt.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs33 = require("fs");
+var import_node_fs34 = require("fs");
 var import_node_os11 = require("os");
-var import_node_path29 = require("path");
+var import_node_path30 = require("path");
 var import_node_module4 = require("module");
 init_worktree();
 init_thread_store();
 var import_meta4 = {};
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path29.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path30.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = (0, import_node_path29.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = (0, import_node_path29.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = (0, import_node_path30.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path30.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function openReadonlySqlite(file) {
   const req = (0, import_node_module4.createRequire)(import_meta4.url);
   const Database = req("better-sqlite3");
@@ -13893,21 +14096,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs33.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs34.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs33.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs34.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path29.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs33.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path30.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs34.existsSync)(agentsFile)) continue;
     let text3;
     try {
-      text3 = (0, import_node_fs33.readFileSync)(agentsFile, "utf8");
+      text3 = (0, import_node_fs34.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -13931,7 +14134,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs33.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs34.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -13958,18 +14161,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs33.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs34.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs33.mkdtempSync)((0, import_node_path29.join)((0, import_node_os11.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path29.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs34.mkdtempSync)((0, import_node_path30.join)((0, import_node_os11.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path30.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs33.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs34.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs33.existsSync)(src)) {
+      if ((0, import_node_fs34.existsSync)(src)) {
         try {
-          (0, import_node_fs33.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs34.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -14045,22 +14248,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs33.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs34.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs33.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs34.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs33.mkdtempSync)((0, import_node_path29.join)((0, import_node_os11.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path29.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs34.mkdtempSync)((0, import_node_path30.join)((0, import_node_os11.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path30.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs33.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs34.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs33.existsSync)(src)) {
+      if ((0, import_node_fs34.existsSync)(src)) {
         try {
-          (0, import_node_fs33.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs34.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -14078,7 +14281,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs33.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs34.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -14141,7 +14344,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs33.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs34.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -14152,8 +14355,8 @@ async function importConductorWorkspaceAsync(workspaceId) {
 var import_node_events = require("events");
 
 // src/slack/outbound-watch.ts
-var import_node_fs35 = require("fs");
-var import_node_path32 = require("path");
+var import_node_fs36 = require("fs");
+var import_node_path33 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
@@ -14199,19 +14402,19 @@ async function slackAuthTest(token) {
 }
 
 // src/slack/reply-target.ts
-var import_node_fs34 = require("fs");
-var import_node_path30 = require("path");
+var import_node_fs35 = require("fs");
+var import_node_path31 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
 function storePath2() {
-  return (0, import_node_path30.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path31.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore2() {
   const path2 = storePath2();
-  if (!(0, import_node_fs34.existsSync)(path2)) return {};
+  if (!(0, import_node_fs35.existsSync)(path2)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs34.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs35.readFileSync)(path2, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -14228,11 +14431,11 @@ function getSlackReplyTarget(threadId) {
 }
 
 // src/slack/workspaces.ts
-var import_node_path31 = require("path");
+var import_node_path32 = require("path");
 init_paths();
 init_secure_file();
 function storePath3() {
-  return (0, import_node_path31.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path32.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore3() {
   try {
@@ -14348,7 +14551,7 @@ var POLL_INTERVAL_MS = 12e3;
 var lastPollMs = 0;
 var nameCache = /* @__PURE__ */ new Map();
 function storePath4() {
-  return (0, import_node_path32.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path33.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -14378,9 +14581,9 @@ function tsNewer(a, b) {
 }
 function readStore4() {
   const path2 = storePath4();
-  if (!(0, import_node_fs35.existsSync)(path2)) return [];
+  if (!(0, import_node_fs36.existsSync)(path2)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs35.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs36.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -14725,7 +14928,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-var import_node_fs41 = require("fs");
+var import_node_fs42 = require("fs");
 init_error_detail();
 init_agents();
 init_worktree();
@@ -14746,8 +14949,8 @@ function shouldAutoArchiveOnPrMerge(opts) {
 }
 
 // src/git/orphan-cleanup.ts
-var import_node_fs36 = require("fs");
-var import_node_path33 = require("path");
+var import_node_fs37 = require("fs");
+var import_node_path34 = require("path");
 init_worktree();
 init_thread_store();
 init_paths();
@@ -14762,9 +14965,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs36.existsSync)(homeRoot)) {
+  if ((0, import_node_fs37.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs36.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs37.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -14774,7 +14977,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs36.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs37.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -14785,7 +14988,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path2);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs36.statSync)(path2).mtimeMs;
+          mtimeMs = (0, import_node_fs37.statSync)(path2).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -14795,16 +14998,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs36.existsSync)(root)) {
-        for (const entry of (0, import_node_fs36.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs37.existsSync)(root)) {
+        for (const entry of (0, import_node_fs37.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path2 = (0, import_node_path33.join)(root, entry.name).replace(/\/$/, "");
+          const path2 = (0, import_node_path34.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path2) || seen.has(path2)) continue;
-          if (!(0, import_node_fs36.existsSync)((0, import_node_path33.join)(path2, ".git"))) continue;
+          if (!(0, import_node_fs37.existsSync)((0, import_node_path34.join)(path2, ".git"))) continue;
           seen.add(path2);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs36.statSync)(path2).mtimeMs;
+            mtimeMs = (0, import_node_fs37.statSync)(path2).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -14950,8 +15153,8 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-var import_node_fs37 = require("fs");
-var import_node_path34 = require("path");
+var import_node_fs38 = require("fs");
+var import_node_path35 = require("path");
 var import_execa6 = require("execa");
 init_paths();
 init_workspaces();
@@ -14961,12 +15164,12 @@ async function cloneRepoIntoSideboard(opts) {
   if (!url) throw new Error("Clone URL is required");
   let name = opts.name?.trim();
   if (!name) {
-    const leaf = (0, import_node_path34.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path35.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path34.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs37.existsSync)(dest)) {
+  const dest = (0, import_node_path35.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs38.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -14988,8 +15191,8 @@ init_orchestrator_capable();
 
 // src/review/request-review.ts
 var import_node_crypto8 = require("crypto");
-var import_node_fs38 = require("fs");
-var import_node_path35 = require("path");
+var import_node_fs39 = require("fs");
+var import_node_path36 = require("path");
 init_global_workspace();
 init_thread_store();
 
@@ -15137,22 +15340,22 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs38.existsSync)(abs)) return null;
+  if (!(0, import_node_fs39.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs38.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs39.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path35.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs38.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs38.mkdirSync)((0, import_node_path35.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs38.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path36.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs39.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs39.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
-  const repoAbs = (0, import_node_path35.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = (0, import_node_path36.join)(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -15162,7 +15365,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = (0, import_node_path35.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path36.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return {
@@ -15172,7 +15375,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
-  const legacyAbs = (0, import_node_path35.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path36.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return {
@@ -15183,8 +15386,8 @@ function resolveReviewGuidelines(worktreePath) {
     };
   }
   ensureAttachmentsGitignore(worktreePath);
-  (0, import_node_fs38.mkdirSync)((0, import_node_path35.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs38.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs39.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -15193,7 +15396,7 @@ function resolveReviewGuidelines(worktreePath) {
   };
 }
 function ensureReviewRequestFile(worktreePath) {
-  const repoAbs = (0, import_node_path35.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = (0, import_node_path36.join)(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -15203,10 +15406,10 @@ function ensureReviewRequestFile(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = (0, import_node_path35.join)(worktreePath, REVIEW_REQUEST_PATH);
-  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent((0, import_node_path35.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  const localAbs = (0, import_node_path36.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent((0, import_node_path36.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
-    const path2 = (0, import_node_fs38.existsSync)(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
+    const path2 = (0, import_node_fs39.existsSync)(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
     return {
       path: path2,
       name: REVIEW_REQUEST_NAME,
@@ -15214,8 +15417,8 @@ function ensureReviewRequestFile(worktreePath) {
       source: "local"
     };
   }
-  (0, import_node_fs38.mkdirSync)((0, import_node_path35.dirname)(repoAbs), { recursive: true });
-  (0, import_node_fs38.writeFileSync)(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(repoAbs), { recursive: true });
+  (0, import_node_fs39.writeFileSync)(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REPO_REVIEW_PATH,
     name: REPO_REVIEW_NAME,
@@ -15235,7 +15438,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent((0, import_node_path35.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path35.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path35.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  return readTextIfPresent((0, import_node_path36.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path36.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path36.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send2) {
   const from = findThreadByRef(threadRef);
@@ -15501,7 +15704,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs41.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs42.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -15752,7 +15955,9 @@ var Orchestrator = class {
       updateThread(thread.id, patch);
       this.emit({ type: "queue_changed", threadId: thread.id, queue });
       this.emit({ type: "status_changed", threadId: thread.id, status: "queued" });
-      void this.drainQueue(thread.id);
+      if (thisProcessShouldDrainAgentQueues()) {
+        void this.drainQueue(thread.id);
+      }
       return this.requireThread(thread.id);
     });
   }
@@ -15805,10 +16010,10 @@ var Orchestrator = class {
   async sendQueuedMessageNow(threadRef, index) {
     const thread = this.requireThread(threadRef);
     const promoted = await withThreadLock(thread.id, async () => {
-      const current = this.requireThread(thread.id);
-      if (index < 0 || index >= current.queue.length) return false;
-      const item = current.queue[index];
-      const rest = current.queue.filter((_, i) => i !== index);
+      const current2 = this.requireThread(thread.id);
+      if (index < 0 || index >= current2.queue.length) return false;
+      const item = current2.queue[index];
+      const rest = current2.queue.filter((_, i) => i !== index);
       const queue = [item, ...rest];
       this.haltDrain.delete(thread.id);
       updateThread(thread.id, { queue });
@@ -15816,10 +16021,16 @@ var Orchestrator = class {
       return true;
     });
     if (!promoted) return this.requireThread(thread.id);
+    const current = this.requireThread(thread.id);
     const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id);
+    const livePid = current.agentPid;
+    const foreignLive = !inFlight && typeof livePid === "number" && livePid > 0 && isPidAlive(livePid);
     if (inFlight) {
       this.stop(thread.id, { clearQueue: false, continueQueue: true });
     } else {
+      if (foreignLive) {
+        this.stop(thread.id, { clearQueue: false, continueQueue: true });
+      }
       void this.drainQueue(thread.id);
     }
     return this.requireThread(thread.id);
@@ -16070,19 +16281,16 @@ var Orchestrator = class {
       }
       let lastStderr = summarizeTurnStderr(stderrTail);
       let detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
-      if (exitCode !== 0 && !assistantText && parts.length === 0 && !this.stoppedTurns.has(threadId) && looksLikeInvalidAgentSession(detail) && this.requireThread(threadId).sessionId && this.requireThread(threadId).agent !== "brightsy") {
+      if (exitCode !== 0 && !assistantText && parts.length === 0 && !this.stoppedTurns.has(threadId) && this.requireThread(threadId).agent !== "brightsy" && shouldRetryFailedAgentTurn(detail, {
+        hasSession: Boolean(this.requireThread(threadId).sessionId)
+      })) {
         updateThread(threadId, { sessionId: null });
-        pushTurnStderr(
-          stderrTail,
-          "Agent session missing \u2014 starting a fresh session"
-        );
+        const retryNote = looksLikeInvalidAgentSession(detail) ? "Agent session missing \u2014 starting a fresh session" : "Agent runner crashed \u2014 restarting Node once";
+        pushTurnStderr(stderrTail, retryNote);
         this.emit({
           type: "turn_output",
           threadId,
-          event: {
-            type: "stderr",
-            data: "Agent session missing \u2014 starting a fresh session"
-          }
+          event: { type: "stderr", data: retryNote }
         });
         const retryThread = this.requireThread(threadId);
         const prior = retryThread.messages.slice(0, -1);
@@ -16131,10 +16339,7 @@ var Orchestrator = class {
         lastStderr = summarizeTurnStderr(stderrTail);
         detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
       }
-      let chatText = assistantText;
-      if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
-        chatText = humanizeAgentFailDetail(detail);
-      }
+      let chatText = this.stoppedTurns.has(threadId) ? assistantText : turnFailChatText({ exitCode, assistantText, detail });
       if (chatText || parts.length > 0) {
         appendMessage(threadId, {
           role: "agent",
@@ -16254,6 +16459,13 @@ var Orchestrator = class {
     if (handle) handle.kill();
     const proc = this.processes.get(`${thread.id}:agent`);
     if (proc) proc.kill();
+    const pid = thread.agentPid;
+    if (typeof pid === "number" && pid > 0 && isPidAlive(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
     const stopped = writeLiveStatus(thread.id, "stopped") ?? readThread(thread.id) ?? thread;
     if (stopped.status === "stopped") {
       this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
@@ -16535,10 +16747,13 @@ var Orchestrator = class {
   getTurnResult(threadRef) {
     const thread = this.requireThread(threadRef);
     const lastAgent = [...thread.messages].reverse().find((m) => m.role === "agent");
+    const lastError = thread.lastError ?? null;
+    const text3 = (lastAgent?.text ?? "").trim() || (thread.status === "error" ? lastError ?? "" : "");
     return {
-      text: lastAgent?.text ?? "",
+      text: text3,
       status: thread.status,
-      sessionId: thread.sessionId
+      sessionId: thread.sessionId,
+      lastError
     };
   }
   assertNotGlobal(thread, action) {
@@ -17034,7 +17249,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!(0, import_node_fs41.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs42.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -17275,7 +17490,7 @@ init_coordinator_prompt();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod3 = require("zod");
-var import_node_path38 = require("path");
+var import_node_path39 = require("path");
 init_worktree();
 init_global_workspace();
 init_list_models();
@@ -17962,7 +18177,7 @@ async function startMcpServer() {
     async () => {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
-        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path38.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path39.basename)(t.repoPath) || t.repoPath;
         return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
       });
       return {
@@ -18319,7 +18534,7 @@ async function startMcpServer() {
     );
     server.tool(
       "wait_for_turn",
-      "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread or ask_git to read the agent reply.",
+      "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread or ask_git. Returns status, text, and lastError. If status is error, lastError/text is the failure \u2014 switch agent, tell the user, or retry; do not treat empty text as success.",
       {
         ref: import_zod3.z.string(),
         timeoutMs: import_zod3.z.number().optional()
@@ -18334,7 +18549,8 @@ async function startMcpServer() {
               text: JSON.stringify({
                 id: thread.id,
                 status: result.status,
-                text: result.text
+                text: result.text,
+                lastError: result.lastError
               })
             }
           ]
@@ -18343,7 +18559,7 @@ async function startMcpServer() {
     );
     server.tool(
       "get_turn_result",
-      "Final assistant message only (not full transcript)",
+      "Final assistant message (and lastError when the turn failed). Not the full transcript.",
       { ref: import_zod3.z.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
@@ -19271,16 +19487,16 @@ init_connected_teams();
 init_injected_mcp();
 
 // src/agents/user-mcp-config.ts
-var import_node_fs42 = require("fs");
+var import_node_fs43 = require("fs");
 var import_node_os12 = require("os");
-var import_node_path39 = require("path");
+var import_node_path40 = require("path");
 init_paths();
 init_injected_mcp();
 function userCursorMcpConfigPath() {
-  return (0, import_node_path39.join)((0, import_node_os12.homedir)(), ".cursor", "mcp.json");
+  return (0, import_node_path40.join)((0, import_node_os12.homedir)(), ".cursor", "mcp.json");
 }
 function userClaudeMcpConfigPath() {
-  return (0, import_node_path39.join)((0, import_node_os12.homedir)(), ".claude.json");
+  return (0, import_node_path40.join)((0, import_node_os12.homedir)(), ".claude.json");
 }
 function asObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
@@ -19307,16 +19523,16 @@ function mergeSideboardIntoMcpServersJson(existing, sideboard) {
 }
 function writeMergedMcpServersJson(configPath, sideboard) {
   let existing = {};
-  if ((0, import_node_fs42.existsSync)(configPath)) {
+  if ((0, import_node_fs43.existsSync)(configPath)) {
     try {
-      existing = JSON.parse((0, import_node_fs42.readFileSync)(configPath, "utf8"));
+      existing = JSON.parse((0, import_node_fs43.readFileSync)(configPath, "utf8"));
     } catch {
       existing = {};
     }
   }
   const next = mergeSideboardIntoMcpServersJson(existing, sideboard);
-  (0, import_node_fs42.mkdirSync)((0, import_node_path39.dirname)(configPath), { recursive: true });
-  (0, import_node_fs42.writeFileSync)(configPath, `${JSON.stringify(next, null, 2)}
+  (0, import_node_fs43.mkdirSync)((0, import_node_path40.dirname)(configPath), { recursive: true });
+  (0, import_node_fs43.writeFileSync)(configPath, `${JSON.stringify(next, null, 2)}
 `);
 }
 function launchFromResolved(server) {
@@ -19334,7 +19550,7 @@ async function registerPackagedUserMcpClients() {
   const cursor = userCursorMcpConfigPath();
   writeMergedMcpServersJson(cursor, launch);
   const claude = userClaudeMcpConfigPath();
-  if ((0, import_node_fs42.existsSync)(claude)) {
+  if ((0, import_node_fs43.existsSync)(claude)) {
     writeMergedMcpServersJson(claude, launch);
     return { cursor, claude };
   }
@@ -20748,9 +20964,9 @@ var import_node_http3 = require("http");
 var import_ws3 = require("ws");
 
 // src/slack/relay-static.ts
-var import_node_fs43 = require("fs");
+var import_node_fs44 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 var TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -20781,9 +20997,9 @@ function resolveStaticPath(root, requestUrl) {
     return null;
   }
   if (!pathname.startsWith("/") || pathname.includes("\0")) return null;
-  const rootResolved = import_node_path40.default.resolve(root);
-  const candidate = import_node_path40.default.resolve(rootResolved, `.${pathname}`);
-  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path40.default.sep)) {
+  const rootResolved = import_node_path41.default.resolve(root);
+  const candidate = import_node_path41.default.resolve(rootResolved, `.${pathname}`);
+  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path41.default.sep)) {
     return null;
   }
   return candidate;
@@ -20797,7 +21013,7 @@ async function fileSize(file) {
   }
 }
 function sendFile(req, res, file, size) {
-  const ext = import_node_path40.default.extname(file).toLowerCase();
+  const ext = import_node_path41.default.extname(file).toLowerCase();
   res.writeHead(200, {
     "Content-Type": TYPES[ext] ?? "application/octet-stream",
     "Content-Length": size,
@@ -20807,7 +21023,7 @@ function sendFile(req, res, file, size) {
     res.end();
     return true;
   }
-  (0, import_node_fs43.createReadStream)(file).pipe(res);
+  (0, import_node_fs44.createReadStream)(file).pipe(res);
   return true;
 }
 async function tryServeStatic(req, res, root) {
@@ -20816,7 +21032,7 @@ async function tryServeStatic(req, res, root) {
   if (!candidate) return false;
   const direct = await fileSize(candidate);
   if (direct != null) return sendFile(req, res, candidate, direct);
-  const asIndex = import_node_path40.default.join(candidate, "index.html");
+  const asIndex = import_node_path41.default.join(candidate, "index.html");
   const indexSize = await fileSize(asIndex);
   if (indexSize != null) return sendFile(req, res, asIndex, indexSize);
   return false;
@@ -21142,6 +21358,7 @@ async function startSlackRelayServer(opts) {
   captureTurnBaseline,
   checkoutPrStackLayer,
   childEnvWithAppSettings,
+  claimDesktopHost,
   claudeAdapter,
   claudeChromeEnabled,
   claudeUserSettingsPath,
@@ -21180,6 +21397,7 @@ async function startSlackRelayServer(opts) {
   decodeBrightsyTarget,
   deleteBranchOnPurgeEnabled,
   deleteThreadRecord,
+  desktopHostPidPath,
   detectAgents,
   detectGhStack,
   detectLocalMergeConflicts,
@@ -21305,6 +21523,7 @@ async function startSlackRelayServer(opts) {
   isConductorBundledCli,
   isCursorAutoModel,
   isDefaultishSourceRef,
+  isDesktopHostAlive,
   isDirty,
   isGhRateLimitError,
   isGlobalRepoPath,
@@ -21326,6 +21545,7 @@ async function startSlackRelayServer(opts) {
   isSlackExternalReplyPrompt,
   isSlackOAuthCancelled,
   isThinkingEffort,
+  isThisProcessDesktopHost,
   isThreadCaffeinated,
   isWorkspaceScratchPath,
   linearAuthorizationHeader,
@@ -21427,6 +21647,7 @@ async function startSlackRelayServer(opts) {
   refreshSlackReplyBadges,
   registerPackagedUserMcpClients,
   releaseCaffeinateHoldForThread,
+  releaseDesktopHost,
   removeWorkspace,
   removeWorktree,
   repoSlug,
@@ -21527,6 +21748,7 @@ async function startSlackRelayServer(opts) {
   taskMessageText,
   thinkingEffortBars,
   thinkingEffortLabel,
+  thisProcessShouldDrainAgentQueues,
   threadDisplayLabel,
   threadFilePath,
   threadLockPath,