@sideboard-ai/core 0.1.97 → 0.1.99

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-QKYO6BHB.js";
+} from "./chunk-UYQYK2RY.js";
 import {
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
@@ -65,7 +65,7 @@ import {
   threadRequestsBrightsyMcp,
   totalTokens,
   writeInjectedMcpConfig
-} from "./chunk-KWNUZ4LR.js";
+} from "./chunk-MBP3XG57.js";
 import {
   CLOUD_COORDINATOR_BUSY_REPLY,
   CLOUD_COORDINATOR_STOPPED_REPLY,
@@ -79,6 +79,7 @@ import {
   createGlobalChat,
   ensureCloudCoordinator,
   ensureSlackCoordinator,
+  findSlackCoordinator,
   healOrchestrationSoccerTitles,
   isCloudCoordinatorThread,
   isGlobalRepoPath,
@@ -92,7 +93,7 @@ import {
   parseForceStopMessage,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-CLGO7TLO.js";
+} from "./chunk-FO67IJTY.js";
 import {
   COORDINATOR_TOOL_PLAYBOOK,
   SLACK_REPLY_FORMATTING,
@@ -366,6 +367,52 @@ import {
   withExportedPath
 } from "./chunk-LGXBYZZA.js";
 
+// src/store/desktop-host.ts
+import { readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+function desktopHostPidPath() {
+  return join(appDataDir(), "desktop-host.pid");
+}
+function claimDesktopHost(pid = process.pid) {
+  writeFileSync(desktopHostPidPath(), `${pid}
+`, "utf8");
+}
+function releaseDesktopHost(pid = process.pid) {
+  if (readDesktopHostPid() !== pid) return;
+  try {
+    unlinkSync(desktopHostPidPath());
+  } catch {
+  }
+}
+function readDesktopHostPid() {
+  try {
+    const pid = Number.parseInt(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/git/agent-git-actions.ts
 var AGENT_GIT_ACTIONS = [
   "commit-push",
@@ -1338,7 +1385,7 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-M3OMVDDH.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-RSQXRLT7.js");
   if (isGlobalThread2(thread)) {
     const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-AKEY4WSO.js");
     ensureGlobalCoordinatorCwd2(
@@ -1451,8 +1498,8 @@ async function spawnAgentTurn(thread, input, onEvent) {
 }
 
 // src/agents/instructions.ts
-import { existsSync, readFileSync, statSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2 } from "path";
 function normPath(p) {
   return p.replace(/\/+$/, "");
 }
@@ -1621,11 +1668,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seenPaths.has(rel)) continue;
-    const abs = join(worktreePath, rel);
+    const abs = join2(worktreePath, rel);
     if (!existsSync(abs)) continue;
     try {
       if (!statSync(abs).isFile()) continue;
-      let content = readFileSync(abs, "utf8");
+      let content = readFileSync2(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -1705,10 +1752,10 @@ import {
   existsSync as existsSync2,
   mkdirSync,
   readdirSync,
-  readFileSync as readFileSync2
+  readFileSync as readFileSync3
 } from "fs";
 import { createServer as createServer2 } from "net";
-import { basename, dirname, join as join2 } from "path";
+import { basename, dirname, join as join3 } from "path";
 import { execa as execa2 } from "execa";
 import { createInterface as createInterface2 } from "readline";
 var PORT_RANGE_SIZE = 10;
@@ -1717,9 +1764,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path2 = join2(repoPath, ".worktreeinclude");
+  const path2 = join3(repoPath, ".worktreeinclude");
   if (!existsSync2(path2)) return [];
-  return readFileSync2(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  return readFileSync3(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -1758,9 +1805,9 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = join2(repoPath, rel);
+    const src = join3(repoPath, rel);
     if (!existsSync2(src)) continue;
-    const dest = join2(worktreePath, rel);
+    const dest = join3(worktreePath, rel);
     mkdirSync(dirname(dest), { recursive: true });
     copyFileSync(src, dest);
     copied.push(rel);
@@ -2055,8 +2102,8 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
 }
 
 // src/diff/diff.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync as statSync2, writeFileSync } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 async function inspectGitWorktree(worktreePath) {
   if (!worktreePath || !existsSync3(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
@@ -2202,11 +2249,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = join3(worktreePath, path2);
+  const abs = join4(worktreePath, path2);
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = readFileSync3(abs).subarray(0, maxHunk);
+      const buf = readFileSync4(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -2707,7 +2754,7 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = join3(worktreePath, relativePath);
+  const abs = join4(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -2717,7 +2764,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = readFileSync3(abs);
+  const buf = readFileSync4(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -2727,12 +2774,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = join3(worktreePath, relativePath);
+  const abs = join4(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = readFileSync3(abs);
+  const buf = readFileSync4(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -2775,9 +2822,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = join3(worktreePath, relativePath);
+  const abs = join4(worktreePath, relativePath);
   mkdirSync2(dirname2(abs), { recursive: true });
-  writeFileSync(abs, content, "utf8");
+  writeFileSync2(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -2796,9 +2843,9 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
 import { homedir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -2830,7 +2877,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = readFileSync4(skillMd, "utf8");
+    const content = readFileSync5(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -2858,7 +2905,7 @@ function scanSkillsDir(dir, source, out) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = join4(dir, entry, "SKILL.md");
+    const skillMd = join5(dir, entry, "SKILL.md");
     if (!existsSync4(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
@@ -2880,12 +2927,12 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill(join4(dir, "SKILL.md"), "cli");
+      const skill = readSkill(join5(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join4(dir, entry);
+      const full = join5(dir, entry);
       try {
         if (!statSync3(full).isDirectory()) continue;
       } catch {
@@ -2905,17 +2952,17 @@ function discoverSkills(worktreePath) {
   const home = homedir();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir(join4(worktreePath, rel), "workspace", collected);
+    scanSkillsDir(join5(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    join4(home, ".claude/skills"),
-    join4(home, ".cursor/skills"),
-    join4(home, ".sideboard/skills"),
-    join4(home, ".brightsy/skills")
+    join5(home, ".claude/skills"),
+    join5(home, ".cursor/skills"),
+    join5(home, ".sideboard/skills"),
+    join5(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills(join4(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills(join5(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -2927,7 +2974,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = readFileSync4(skillPath, "utf8");
+  const raw = readFileSync5(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -3068,8 +3115,8 @@ function buildDiffCommentAttachment(input) {
 }
 
 // src/composer/stage-files.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename2, extname, join as join5 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename2, extname, join as join6 } from "path";
 import { randomUUID } from "crypto";
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
@@ -3104,22 +3151,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = join5(worktreePath, ATTACHMENTS_DIR);
+  const dir = join6(worktreePath, ATTACHMENTS_DIR);
   mkdirSync3(dir, { recursive: true });
-  const gi = join5(dir, ".gitignore");
+  const gi = join6(dir, ".gitignore");
   if (!existsSync5(gi)) {
-    writeFileSync2(gi, attachmentsGitignoreBody(), "utf8");
+    writeFileSync3(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!existsSync5(join5(dir, safe))) return safe;
+  if (!existsSync5(join6(dir, safe))) return safe;
   const ext = extname(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!existsSync5(join5(dir, candidate))) return candidate;
+    if (!existsSync5(join6(dir, candidate))) return candidate;
   }
   return `${stem}-${randomUUID()}${ext}`;
 }
@@ -3182,7 +3229,7 @@ function attachmentFromAbsolutePath(absolutePath) {
         content: `(not a file: ${absolutePath})`
       };
     }
-    const buf = readFileSync5(absolutePath);
+    const buf = readFileSync6(absolutePath);
     return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
   } catch (err) {
     return {
@@ -3203,10 +3250,10 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
       const st = statSync4(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = join5(dir, name);
+      const destAbs = join6(dir, name);
       copyFileSync2(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = readFileSync5(destAbs);
+      const buf = readFileSync6(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -3228,8 +3275,8 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = join5(dir, name);
-      writeFileSync2(destAbs, buf);
+      const destAbs = join6(dir, name);
+      writeFileSync3(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -3273,10 +3320,10 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     }
     const name = basename2(rel);
     try {
-      const abs = join5(worktreePath, rel);
+      const abs = join6(worktreePath, rel);
       const st = statSync4(abs);
       if (!st.isFile()) continue;
-      const buf = readFileSync5(abs);
+      const buf = readFileSync6(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -3833,7 +3880,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-WS5QV6LE.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-3MWWWSMF.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3913,6 +3960,7 @@ function createChatTab(input) {
   if (isOrchestratorThread(from) || binding.sourceType === "orchestration") {
     assertOrchestratorCapableAgent(nextAgent);
   }
+  const singletonInbox = isSlackCoordinatorThread(from) || isCloudCoordinatorThread(from);
   const thread = createEmptyThread({
     title,
     // Chat-tab nicknames (soccer team or explicit) must stick. Post-turn
@@ -3920,6 +3968,10 @@ function createChatTab(input) {
     // shared worktree folder name (e.g. fork "Arsenal" → "Monaco").
     userSetTitle: true,
     ...binding,
+    // Slack / Brightsy cloud identity stays on the original chat. A + tab
+    // that copies `slack:team:user` would steal inbound DMs after you close
+    // the connected chat.
+    sourceRef: singletonInbox ? title : binding.sourceRef,
     agent: nextAgent,
     model: input.model !== void 0 ? input.model : input.agent && input.agent !== from.agent ? null : from.model,
     effort: input.effort !== void 0 ? input.effort : from.effort,
@@ -4294,20 +4346,20 @@ import {
   existsSync as existsSync8,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { createRequire } from "module";
-var CONDUCTOR_APP_SUPPORT = join6(
+var CONDUCTOR_APP_SUPPORT = join7(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join6(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join6(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join7(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join7(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function openReadonlySqlite(file) {
   const req = createRequire(import.meta.url);
   const Database = req("better-sqlite3");
@@ -4334,11 +4386,11 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join6(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    const agentsFile = join7(CURSOR_SDK_STORE, hash, "agents.ndjson");
     if (!existsSync8(agentsFile)) continue;
     let text3;
     try {
-      text3 = readFileSync6(agentsFile, "utf8");
+      text3 = readFileSync7(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -4381,7 +4433,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ERZC7ULY.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-4ZY4QPWQ.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -4392,8 +4444,8 @@ function listConductorWorkspaces() {
   if (!existsSync8(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join6(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join6(tmp, "conductor.db");
+  const tmp = mkdtempSync(join7(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join7(tmp, "conductor.db");
   try {
     copyFileSync3(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
@@ -4483,8 +4535,8 @@ function importConductorWorkspace(workspaceId) {
   if (!existsSync8(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join6(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join6(tmp, "conductor.db");
+  const tmp = mkdtempSync(join7(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join7(tmp, "conductor.db");
   try {
     copyFileSync3(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
@@ -4583,8 +4635,8 @@ async function importConductorWorkspaceAsync(workspaceId) {
 import { EventEmitter } from "events";
 
 // src/slack/outbound-watch.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join10 } from "path";
 
 // src/slack/api.ts
 var SLACK_API = "https://slack.com/api";
@@ -4626,16 +4678,16 @@ async function slackAuthTest(token) {
 }
 
 // src/slack/reply-target.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { join as join8 } from "path";
 function storePath() {
-  return join7(appDataDir(), "slack-reply-to.json");
+  return join8(appDataDir(), "slack-reply-to.json");
 }
 function readStore() {
   const path2 = storePath();
   if (!existsSync9(path2)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse(readFileSync7(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse(readFileSync8(path2, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -4652,9 +4704,9 @@ function getSlackReplyTarget(threadId) {
 }
 
 // src/slack/workspaces.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function storePath2() {
-  return join8(appDataDir(), "slack-workspaces.json");
+  return join9(appDataDir(), "slack-workspaces.json");
 }
 function readStore2() {
   try {
@@ -4770,7 +4822,7 @@ var POLL_INTERVAL_MS = 12e3;
 var lastPollMs = 0;
 var nameCache = /* @__PURE__ */ new Map();
 function storePath3() {
-  return join9(appDataDir(), "slack-outbound-watch.json");
+  return join10(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -4802,7 +4854,7 @@ function readStore3() {
   const path2 = storePath3();
   if (!existsSync10(path2)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse(readFileSync8(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse(readFileSync9(path2, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -5165,7 +5217,7 @@ function shouldAutoArchiveOnPrMerge(opts) {
 
 // src/git/orphan-cleanup.ts
 import { existsSync as existsSync11, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function isSideboardWorktreePath(path2) {
   return path2.includes("/.sideboard/worktrees/") || path2.includes("/sideboard/workspaces/");
 }
@@ -5212,9 +5264,9 @@ async function findOrphanWorktrees(repoPaths) {
       if (existsSync11(root)) {
         for (const entry of readdirSync4(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path2 = join10(root, entry.name).replace(/\/$/, "");
+          const path2 = join11(root, entry.name).replace(/\/$/, "");
           if (known.has(path2) || seen.has(path2)) continue;
-          if (!existsSync11(join10(path2, ".git"))) continue;
+          if (!existsSync11(join11(path2, ".git"))) continue;
           seen.add(path2);
           let mtimeMs = 0;
           try {
@@ -5364,7 +5416,7 @@ async function applyThreadIntoMain(thread, opts) {
 
 // src/git/clone-repo.ts
 import { existsSync as existsSync12 } from "fs";
-import { basename as basename3, join as join11 } from "path";
+import { basename as basename3, join as join12 } from "path";
 import { execa as execa4 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
   const url = opts.url.trim();
@@ -5375,7 +5427,7 @@ async function cloneRepoIntoSideboard(opts) {
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = join11(sideboardReposDir(), name);
+  const dest = join12(sideboardReposDir(), name);
   if (existsSync12(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
@@ -5394,8 +5446,8 @@ async function cloneRepoIntoSideboard(opts) {
 
 // src/review/request-review.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join12 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, join as join13 } from "path";
 
 // src/review/review-request-template.ts
 var REVIEW_REQUEST_TEMPLATE = `# Review guidelines:
@@ -5542,20 +5594,20 @@ function shouldRefreshReviewRequestTemplate(content) {
 function readTextIfPresent(abs) {
   if (!existsSync13(abs)) return null;
   try {
-    const content = readFileSync9(abs, "utf8");
+    const content = readFileSync10(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = join12(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  const gitignoreAbs = join13(worktreePath, ATTACHMENTS_DIR, ".gitignore");
   if (existsSync13(gitignoreAbs)) return;
   mkdirSync4(dirname3(gitignoreAbs), { recursive: true });
-  writeFileSync3(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  writeFileSync4(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
-  const repoAbs = join12(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = join13(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -5565,7 +5617,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = join12(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = join13(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return {
@@ -5575,7 +5627,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
-  const legacyAbs = join12(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = join13(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return {
@@ -5587,7 +5639,7 @@ function resolveReviewGuidelines(worktreePath) {
   }
   ensureAttachmentsGitignore(worktreePath);
   mkdirSync4(dirname3(localAbs), { recursive: true });
-  writeFileSync3(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  writeFileSync4(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -5596,7 +5648,7 @@ function resolveReviewGuidelines(worktreePath) {
   };
 }
 function ensureReviewRequestFile(worktreePath) {
-  const repoAbs = join12(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = join13(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -5606,8 +5658,8 @@ function ensureReviewRequestFile(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = join12(worktreePath, REVIEW_REQUEST_PATH);
-  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent(join12(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  const localAbs = join13(worktreePath, REVIEW_REQUEST_PATH);
+  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent(join13(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     const path2 = existsSync13(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
     return {
@@ -5618,7 +5670,7 @@ function ensureReviewRequestFile(worktreePath) {
     };
   }
   mkdirSync4(dirname3(repoAbs), { recursive: true });
-  writeFileSync3(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  writeFileSync4(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REPO_REVIEW_PATH,
     name: REPO_REVIEW_NAME,
@@ -5638,7 +5690,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent(join12(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent(join12(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent(join12(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  return readTextIfPresent(join13(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent(join13(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent(join13(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send2) {
   const from = findThreadByRef(threadRef);
@@ -6126,6 +6178,9 @@ var Orchestrator = class {
     }
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
+      if (current.status === "archived") {
+        throw new Error(`Thread is archived: ${thread.id}`);
+      }
       const queue = [...current.queue, prompt];
       this.haltDrain.delete(thread.id);
       const patch = { queue, status: "queued" };
@@ -6136,7 +6191,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);
     });
   }
@@ -6189,10 +6246,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 });
@@ -6200,10 +6257,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);
@@ -6638,6 +6701,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" });
@@ -7376,7 +7446,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ERZC7ULY.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-4ZY4QPWQ.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -9623,14 +9693,14 @@ async function runCloudConnect(opts) {
 }
 
 // src/agents/user-mcp-config.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join13 } from "path";
+import { dirname as dirname4, join as join14 } from "path";
 function userCursorMcpConfigPath() {
-  return join13(homedir2(), ".cursor", "mcp.json");
+  return join14(homedir2(), ".cursor", "mcp.json");
 }
 function userClaudeMcpConfigPath() {
-  return join13(homedir2(), ".claude.json");
+  return join14(homedir2(), ".claude.json");
 }
 function asObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
@@ -9659,14 +9729,14 @@ function writeMergedMcpServersJson(configPath, sideboard) {
   let existing = {};
   if (existsSync15(configPath)) {
     try {
-      existing = JSON.parse(readFileSync10(configPath, "utf8"));
+      existing = JSON.parse(readFileSync11(configPath, "utf8"));
     } catch {
       existing = {};
     }
   }
   const next = mergeSideboardIntoMcpServersJson(existing, sideboard);
   mkdirSync5(dirname4(configPath), { recursive: true });
-  writeFileSync4(configPath, `${JSON.stringify(next, null, 2)}
+  writeFileSync5(configPath, `${JSON.stringify(next, null, 2)}
 `);
 }
 function launchFromResolved(server) {
@@ -10480,11 +10550,16 @@ function slackInboundSuperseded(opts) {
   }
   return opts.currentInboundGeneration() !== opts.inboundGeneration;
 }
-function interruptSlackCoordinatorForInbound(msg, agent, log = () => void 0) {
+function slackCoordinatorGone(err) {
+  const errMsg = err instanceof Error ? err.message : String(err);
+  return /thread not found|thread is archived/i.test(errMsg);
+}
+function interruptSlackCoordinatorForInbound(msg, _agent, log = () => void 0) {
   const userId = msg.userId?.trim();
   if (!userId) return false;
   try {
-    const coordinator = ensureSlackCoordinator(msg.teamId, userId, agent);
+    const coordinator = findSlackCoordinator(msg.teamId, userId);
+    if (!coordinator) return false;
     const fresh = readThread(coordinator.id) ?? coordinator;
     if (fresh.status !== "running" && fresh.status !== "queued") return false;
     getOrchestrator().stop(fresh.id, { clearQueue: true });
@@ -10650,15 +10725,16 @@ async function handleSlackInbound(msg, opts) {
     log(`skip superseded ${msg.kind} ${msg.ts}`);
     return;
   }
-  const coordinator = ensureSlackCoordinator(msg.teamId, userId, agent);
-  let fresh = readThread(coordinator.id) ?? coordinator;
   if (isSlackStopCommand(msg.text)) {
-    try {
-      getOrchestrator().stop(fresh.id, { clearQueue: true });
-      log(`stop ${msg.kind} ${msg.ts} \u2192 coordinator ${fresh.id.slice(0, 8)}`);
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      log(`stop ${msg.ts}: ${errMsg}`);
+    const live = findSlackCoordinator(msg.teamId, userId);
+    if (live) {
+      try {
+        getOrchestrator().stop(live.id, { clearQueue: true });
+        log(`stop ${msg.kind} ${msg.ts} \u2192 coordinator ${live.id.slice(0, 8)}`);
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log(`stop ${msg.ts}: ${errMsg}`);
+      }
     }
     if (slackInboundSuperseded(opts)) {
       log(`skip superseded stop reply ${msg.ts}`);
@@ -10668,34 +10744,65 @@ async function handleSlackInbound(msg, opts) {
     log(`replied stopped ${msg.ts}`);
     return;
   }
+  const opened = ensureSlackCoordinator(msg.teamId, userId, agent);
+  let fresh = readThread(opened.id) ?? opened;
   if (fresh.status === "running" || fresh.status === "queued") {
     interruptSlackCoordinatorForInbound(msg, agent, log);
-    fresh = readThread(coordinator.id) ?? coordinator;
+    fresh = readThread(fresh.id) ?? fresh;
   }
   log(
     `run ${msg.kind} ${msg.ts} user ${userId} \u2192 coordinator ${fresh.id.slice(0, 8)} (${inventory.length} workspace${inventory.length === 1 ? "" : "s"})`
   );
   const prompt = formatSlackInboundPrompt(msg);
-  setSlackReplyTarget({
-    threadId: fresh.id,
-    teamId: msg.teamId,
-    channelId: msg.channelId,
-    threadTs: slackReplyThreadTs(msg)
-  });
   const orch = getOrchestrator();
+  const bindReplyTarget = (threadId) => {
+    setSlackReplyTarget({
+      threadId,
+      teamId: msg.teamId,
+      channelId: msg.channelId,
+      threadTs: slackReplyThreadTs(msg)
+    });
+  };
+  bindReplyTarget(fresh.id);
+  const runTurn = async (threadId) => {
+    await orch.send(threadId, prompt);
+    await orch.waitForTurn(threadId, 14 * 60 * 1e3);
+  };
   let reply;
   try {
-    await orch.send(fresh.id, prompt);
-    await orch.waitForTurn(fresh.id, 14 * 60 * 1e3);
+    try {
+      await runTurn(fresh.id);
+    } catch (err) {
+      if (!slackCoordinatorGone(err)) throw err;
+      log(`coordinator ${fresh.id.slice(0, 8)} gone, opening a new chat`);
+      fresh = ensureSlackCoordinator(msg.teamId, userId, agent, { forceNew: true });
+      bindReplyTarget(fresh.id);
+      await runTurn(fresh.id);
+    }
     if (slackInboundSuperseded(opts)) {
       log(`turn finished ${msg.ts} (superseded)`);
       return;
     }
-    const after = readThread(fresh.id);
-    if (!after || after.status === "stopped" || after.status === "archived") {
+    let after = readThread(fresh.id);
+    if (after?.status === "stopped") {
       log(`turn finished ${msg.ts} (interrupted, skip post)`);
       return;
     }
+    if (!after || after.status === "archived") {
+      log(`coordinator ${fresh.id.slice(0, 8)} closed, opening a new chat`);
+      fresh = ensureSlackCoordinator(msg.teamId, userId, agent, { forceNew: true });
+      bindReplyTarget(fresh.id);
+      await runTurn(fresh.id);
+      if (slackInboundSuperseded(opts)) {
+        log(`turn finished ${msg.ts} (superseded)`);
+        return;
+      }
+      after = readThread(fresh.id);
+      if (!after || after.status === "stopped" || after.status === "archived") {
+        log(`turn finished ${msg.ts} (interrupted, skip post)`);
+        return;
+      }
+    }
     reply = orch.getTurnResult(fresh.id).text.trim();
   } catch (err) {
     if (slackInboundSuperseded(opts)) {
@@ -10703,8 +10810,7 @@ async function handleSlackInbound(msg, opts) {
       return;
     }
     const errMsg = err instanceof Error ? err.message : String(err);
-    const gone = /thread not found/i.test(errMsg);
-    if (gone) {
+    if (slackCoordinatorGone(err)) {
       log(`turn finished ${msg.ts} (thread gone, skip post)`);
       return;
     }
@@ -11447,6 +11553,7 @@ export {
   captureTurnBaseline,
   checkoutPrStackLayer,
   childEnvWithAppSettings,
+  claimDesktopHost,
   claudeAdapter,
   claudeChromeEnabled,
   claudeUserSettingsPath,
@@ -11485,6 +11592,7 @@ export {
   decodeBrightsyTarget,
   deleteBranchOnPurgeEnabled,
   deleteThreadRecord,
+  desktopHostPidPath,
   detectAgents,
   detectGhStack,
   detectLocalMergeConflicts,
@@ -11518,6 +11626,7 @@ export {
   findConventionSetup,
   findInvalidCacheControlTtlOrder,
   findOrphanWorktrees,
+  findSlackCoordinator,
   findThreadByRef,
   findThreadForStackLayer,
   flattenTurnInput,
@@ -11609,6 +11718,7 @@ export {
   isConductorBundledCli,
   isCursorAutoModel,
   isDefaultishSourceRef,
+  isDesktopHostAlive,
   isDirty,
   isGhRateLimitError,
   isGlobalRepoPath,
@@ -11630,6 +11740,7 @@ export {
   isSlackExternalReplyPrompt,
   isSlackOAuthCancelled,
   isThinkingEffort,
+  isThisProcessDesktopHost,
   isThreadCaffeinated,
   isWorkspaceScratchPath,
   linearAuthorizationHeader,
@@ -11731,6 +11842,7 @@ export {
   refreshSlackReplyBadges,
   registerPackagedUserMcpClients,
   releaseCaffeinateHoldForThread,
+  releaseDesktopHost,
   removeWorkspace,
   removeWorktree,
   repoSlug,
@@ -11831,6 +11943,7 @@ export {
   taskMessageText,
   thinkingEffortBars,
   thinkingEffortLabel,
+  thisProcessShouldDrainAgentQueues,
   threadDisplayLabel,
   threadFilePath,
   threadLockPath,