@sideboard-ai/core 0.1.98 → 0.1.99

package/dist/mcp/run-stdio.cjs

@@ -8644,40 +8644,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore2(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 planFileAbs(worktreePath) {
-  return (0, import_node_path35.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path36.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(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 readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path35.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path35.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  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));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore2(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs38.mkdirSync)((0, import_node_path35.dirname)(abs), { recursive: true });
+  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs38.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs39.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs38, import_node_path35;
+var import_node_fs39, import_node_path36;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs38 = require("fs");
-    import_node_path35 = require("path");
+    import_node_fs39 = require("fs");
+    import_node_path36 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -8698,7 +8698,7 @@ function setCaffeinateHoldHooks(next) {
   hooks = next;
 }
 function caffeinateHoldPath() {
-  return (0, import_node_path36.join)(appDataDir(), "caffeinate-hold.json");
+  return (0, import_node_path37.join)(appDataDir(), "caffeinate-hold.json");
 }
 function processAlive(pid) {
   if (hooks.processAlive) return hooks.processAlive(pid);
@@ -8732,9 +8732,9 @@ function uniqueIds(ids) {
 }
 function readHold() {
   const path = caffeinateHoldPath();
-  if (!(0, import_node_fs39.existsSync)(path)) return null;
+  if (!(0, import_node_fs40.existsSync)(path)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs39.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs40.readFileSync)(path, "utf8"));
     if (typeof parsed?.pid === "number" && parsed.pid > 0) {
       return {
         pid: parsed.pid,
@@ -8756,7 +8756,7 @@ function writeHold(pid, threadIds) {
 }
 function clearHold() {
   try {
-    (0, import_node_fs39.unlinkSync)(caffeinateHoldPath());
+    (0, import_node_fs40.unlinkSync)(caffeinateHoldPath());
   } catch {
   }
 }
@@ -8841,13 +8841,13 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process4, import_node_fs39, import_node_path36, hooks;
+var import_node_child_process4, import_node_fs40, import_node_path37, hooks;
 var init_caffeinate_hold = __esm({
   "src/store/caffeinate-hold.ts"() {
     "use strict";
     import_node_child_process4 = require("child_process");
-    import_node_fs39 = require("fs");
-    import_node_path36 = require("path");
+    import_node_fs40 = require("fs");
+    import_node_path37 = require("path");
     init_paths();
     init_private_file();
     hooks = {};
@@ -8862,10 +8862,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();
@@ -8891,12 +8891,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();
   }
 });
@@ -8908,7 +8908,7 @@ init_nested_electron_env();
 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");
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
@@ -9419,7 +9419,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-var import_node_fs41 = require("fs");
+var import_node_fs42 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -10536,8 +10536,44 @@ async function cloneRepoIntoSideboard(opts) {
 // src/orchestrator/orchestrator.ts
 init_thread_store();
 
-// src/threads/create.ts
+// src/store/desktop-host.ts
 var import_node_fs30 = require("fs");
+var import_node_path29 = require("path");
+init_paths();
+function desktopHostPidPath() {
+  return (0, import_node_path29.join)(appDataDir(), "desktop-host.pid");
+}
+function readDesktopHostPid() {
+  try {
+    const pid = Number.parseInt((0, import_node_fs30.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/threads/create.ts
+var import_node_fs31 = require("fs");
 
 // src/detect/detect.ts
 init_agents();
@@ -10582,7 +10618,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs30.existsSync)(repoPath)) {
+  if (!(0, import_node_fs31.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -11058,8 +11094,8 @@ function forkChatTab(input) {
 
 // src/review/request-review.ts
 var import_node_crypto5 = require("crypto");
-var import_node_fs31 = require("fs");
-var import_node_path29 = require("path");
+var import_node_fs32 = require("fs");
+var import_node_path30 = require("path");
 init_global_workspace();
 init_thread_store();
 
@@ -11207,22 +11243,22 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs31.existsSync)(abs)) return null;
+  if (!(0, import_node_fs32.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs31.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs32.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path29.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs31.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs31.mkdirSync)((0, import_node_path29.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs31.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path30.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs32.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs32.mkdirSync)((0, import_node_path30.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs32.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
-  const repoAbs = (0, import_node_path29.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = (0, import_node_path30.join)(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -11232,7 +11268,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = (0, import_node_path29.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path30.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return {
@@ -11242,7 +11278,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
-  const legacyAbs = (0, import_node_path29.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path30.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return {
@@ -11253,8 +11289,8 @@ function resolveReviewGuidelines(worktreePath) {
     };
   }
   ensureAttachmentsGitignore(worktreePath);
-  (0, import_node_fs31.mkdirSync)((0, import_node_path29.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs31.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs32.mkdirSync)((0, import_node_path30.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs32.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -11454,21 +11490,21 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 
 // src/threads/adopt.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs32 = require("fs");
+var import_node_fs33 = require("fs");
 var import_node_os10 = require("os");
-var import_node_path30 = require("path");
+var import_node_path31 = require("path");
 var import_node_module4 = require("module");
 init_worktree();
 init_thread_store();
 var import_meta4 = {};
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path30.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path31.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-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");
+var CONDUCTOR_DB = (0, import_node_path31.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path31.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");
@@ -11485,21 +11521,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs32.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs33.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs32.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs33.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path30.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs32.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path31.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs33.existsSync)(agentsFile)) continue;
     let text3;
     try {
-      text3 = (0, import_node_fs32.readFileSync)(agentsFile, "utf8");
+      text3 = (0, import_node_fs33.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -11523,7 +11559,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs32.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs33.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -11547,18 +11583,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs32.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs33.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs32.mkdtempSync)((0, import_node_path30.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path30.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs33.mkdtempSync)((0, import_node_path31.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path31.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs32.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs33.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs32.existsSync)(src)) {
+      if ((0, import_node_fs33.existsSync)(src)) {
         try {
-          (0, import_node_fs32.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs33.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -11634,22 +11670,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs32.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs33.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs32.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs33.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs32.mkdtempSync)((0, import_node_path30.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path30.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs33.mkdtempSync)((0, import_node_path31.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path31.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs32.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs33.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs32.existsSync)(src)) {
+      if ((0, import_node_fs33.existsSync)(src)) {
         try {
-          (0, import_node_fs32.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs33.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -11667,7 +11703,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_fs32.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs33.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -11730,7 +11766,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs32.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs33.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -11738,7 +11774,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-var import_node_fs33 = require("fs");
+var import_node_fs34 = require("fs");
 init_run();
 init_stack();
 init_worktree();
@@ -11806,7 +11842,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_fs33.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs34.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -11948,7 +11984,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_fs33.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs34.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);
@@ -12015,7 +12051,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs33.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs34.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -12030,12 +12066,12 @@ async function createPrStack(input, onSetupLine) {
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs34 = require("fs");
-var import_node_path31 = require("path");
+var import_node_fs35 = require("fs");
+var import_node_path32 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs34.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs35.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -12043,7 +12079,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs34.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs35.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -12179,11 +12215,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = (0, import_node_path31.join)(worktreePath, path);
+  const abs = (0, import_node_path32.join)(worktreePath, path);
   try {
-    const st = (0, import_node_fs34.statSync)(abs);
+    const st = (0, import_node_fs35.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs34.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs35.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -12684,8 +12720,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_path31.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs34.statSync)(abs);
+  const abs = (0, import_node_path32.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs35.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -12694,7 +12730,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs34.readFileSync)(abs);
+  const buf = (0, import_node_fs35.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -12704,12 +12740,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path31.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs34.statSync)(abs);
+  const abs = (0, import_node_path32.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs35.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs34.readFileSync)(abs);
+  const buf = (0, import_node_fs35.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -12752,9 +12788,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path31.join)(worktreePath, relativePath);
-  (0, import_node_fs34.mkdirSync)((0, import_node_path31.dirname)(abs), { recursive: true });
-  (0, import_node_fs34.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path32.join)(worktreePath, relativePath);
+  (0, import_node_fs35.mkdirSync)((0, import_node_path32.dirname)(abs), { recursive: true });
+  (0, import_node_fs35.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -12858,9 +12894,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs35 = require("fs");
+var import_node_fs36 = require("fs");
 var import_node_os11 = require("os");
-var import_node_path32 = require("path");
+var import_node_path33 = require("path");
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -12892,7 +12928,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs35.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs36.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -12911,19 +12947,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs35.existsSync)(dir)) return;
+  if (!(0, import_node_fs36.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs35.readdirSync)(dir);
+    entries = (0, import_node_fs36.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path32.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs35.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path33.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs36.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs35.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs36.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -12932,24 +12968,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs35.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs36.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs35.readdirSync)(dir);
+      entries = (0, import_node_fs36.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path32.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path33.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_path32.join)(dir, entry);
+      const full = (0, import_node_path33.join)(dir, entry);
       try {
-        if (!(0, import_node_fs35.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs36.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -12967,17 +13003,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os11.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path32.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path33.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path32.join)(home, ".claude/skills"),
-    (0, import_node_path32.join)(home, ".cursor/skills"),
-    (0, import_node_path32.join)(home, ".sideboard/skills"),
-    (0, import_node_path32.join)(home, ".brightsy/skills")
+    (0, import_node_path33.join)(home, ".claude/skills"),
+    (0, import_node_path33.join)(home, ".cursor/skills"),
+    (0, import_node_path33.join)(home, ".sideboard/skills"),
+    (0, import_node_path33.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path32.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path33.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -12989,7 +13025,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_fs35.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs36.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -13082,8 +13118,8 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.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");
 var import_node_crypto7 = require("crypto");
 init_workspace_scratch();
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -13109,7 +13145,7 @@ var IMAGE_MIME_BY_EXT = {
 var MAX_INLINE_BYTES = 4e5;
 var MAX_PREVIEW_BYTES = 5e6;
 function fileExtension(filePath) {
-  const base = (0, import_node_path33.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path34.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -13119,22 +13155,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path33.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs36.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path33.join)(dir, ".gitignore");
-  if (!(0, import_node_fs36.existsSync)(gi)) {
-    (0, import_node_fs36.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  const dir = (0, import_node_path34.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs37.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path34.join)(dir, ".gitignore");
+  if (!(0, import_node_fs37.existsSync)(gi)) {
+    (0, import_node_fs37.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs36.existsSync)((0, import_node_path33.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path33.extname)(safe);
+  if (!(0, import_node_fs37.existsSync)((0, import_node_path34.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path34.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_fs36.existsSync)((0, import_node_path33.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs37.existsSync)((0, import_node_path34.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto7.randomUUID)()}${ext}`;
 }
@@ -13190,15 +13226,15 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path33.basename)(abs);
+    const originalName = (0, import_node_path34.basename)(abs);
     try {
-      const st = (0, import_node_fs36.statSync)(abs);
+      const st = (0, import_node_fs37.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path33.join)(dir, name);
-      (0, import_node_fs36.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path34.join)(dir, name);
+      (0, import_node_fs37.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs36.readFileSync)(destAbs);
+      const buf = (0, import_node_fs37.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13220,8 +13256,8 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path33.join)(dir, name);
-      (0, import_node_fs36.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path34.join)(dir, name);
+      (0, import_node_fs37.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -13241,18 +13277,18 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
         id: (0, import_node_crypto7.randomUUID)(),
-        name: (0, import_node_path33.basename)(rel) || "file",
+        name: (0, import_node_path34.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path33.basename)(rel);
+    const name = (0, import_node_path34.basename)(rel);
     try {
-      const abs = (0, import_node_path33.join)(worktreePath, rel);
-      const st = (0, import_node_fs36.statSync)(abs);
+      const abs = (0, import_node_path34.join)(worktreePath, rel);
+      const st = (0, import_node_fs37.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs36.readFileSync)(abs);
+      const buf = (0, import_node_fs37.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13267,8 +13303,8 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.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");
 init_git_auth_mode();
 init_worktree_labels();
 function normPath3(p) {
@@ -13548,7 +13584,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;
@@ -13799,7 +13835,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);
     });
   }
@@ -13852,10 +13890,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 });
@@ -13863,10 +13901,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);
@@ -14301,6 +14345,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" });
@@ -15081,7 +15132,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();
@@ -16321,7 +16372,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 {