@sideboard-ai/core 0.1.99 → 0.1.103

package/dist/mcp/run-stdio.cjs

@@ -416,6 +416,7 @@ __export(paths_exports, {
   sideboardReposDir: () => sideboardReposDir,
   sideboardWorkspacesDir: () => sideboardWorkspacesDir,
   threadFilePath: () => threadFilePath,
+  threadLivePath: () => threadLivePath,
   threadLockPath: () => threadLockPath,
   threadsDir: () => threadsDir,
   worktreesRoot: () => worktreesRoot
@@ -467,6 +468,9 @@ function worktreesRoot(repoPath) {
 function threadFilePath(id) {
   return (0, import_node_path5.join)(threadsDir(), `${id}.json`);
 }
+function threadLivePath(id) {
+  return (0, import_node_path5.join)(threadsDir(), `${id}.live.json`);
+}
 function threadLockPath(id) {
   return (0, import_node_path5.join)(locksDir(), `${id}.lock`);
 }
@@ -759,8 +763,11 @@ function writeThread(thread) {
 function idPath(id) {
   return id;
 }
+function isThreadRecordFile(name) {
+  return name.endsWith(".json") && !name.endsWith(".live.json");
+}
 function listThreads(opts) {
-  const files = (0, import_node_fs7.readdirSync)(threadsDir()).filter((f) => f.endsWith(".json"));
+  const files = (0, import_node_fs7.readdirSync)(threadsDir()).filter(isThreadRecordFile);
   const threads = files.map((f) => {
     try {
       return normalizeThread(
@@ -769,7 +776,9 @@ function listThreads(opts) {
     } catch {
       return null;
     }
-  }).filter((t) => t !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }).filter(
+    (t) => t !== null && typeof t.id === "string" && t.id.length > 0
+  ).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   if (opts?.includeArchived) return threads;
   return threads.filter((t) => t.status !== "archived");
 }
@@ -801,7 +810,9 @@ function setStatus(id, status, lastError) {
 }
 function findThreadByRef(ref) {
   const all = listThreads({ includeArchived: true });
-  return all.find((t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref) ?? null;
+  return all.find(
+    (t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref
+  ) ?? null;
 }
 var import_node_crypto2, import_node_fs7, import_proper_lockfile;
 var init_thread_store = __esm({
@@ -883,6 +894,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;
@@ -893,6 +911,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)
   )) {
@@ -915,6 +934,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;
@@ -959,11 +992,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();
@@ -977,12 +1021,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)";
   }
 });
@@ -1764,7 +1809,7 @@ var init_teams = __esm({
 
 // src/git/worktree-labels.ts
 function normalizeWorktreePath(worktreePath) {
-  const trimmed = worktreePath.replace(/\/+$/, "") || "/";
+  const trimmed = (worktreePath ?? "").replace(/\/+$/, "") || "/";
   const absolute = trimmed.startsWith("/");
   const parts = trimmed.split("/").filter((p) => p && p !== ".");
   const out = [];
@@ -3355,6 +3400,42 @@ var init_git_auth_mode = __esm({
   }
 });
 
+// src/util/enqueue-by-key.ts
+function enqueueByKey(key, fn) {
+  const prev = tails.get(key) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  tails.set(
+    key,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+var tails;
+var init_enqueue_by_key = __esm({
+  "src/util/enqueue-by-key.ts"() {
+    "use strict";
+    tails = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/git/repo-git-lock.ts
+function repoLockKey(repoPath) {
+  const trimmed = repoPath.replace(/\/+$/, "");
+  return `git-worktree:${trimmed || "/"}`;
+}
+function withRepoGitLock(repoPath, fn) {
+  return enqueueByKey(repoLockKey(repoPath), fn);
+}
+var init_repo_git_lock = __esm({
+  "src/git/repo-git-lock.ts"() {
+    "use strict";
+    init_enqueue_by_key();
+  }
+});
+
 // src/git/pr-gates.ts
 function prIsInMergeQueue(gate) {
   if (gate.isInMergeQueue) return true;
@@ -4508,12 +4589,13 @@ async function createThreadWorktree(opts) {
       `Invalid git reference: ${opts.sourceRef} (and fetch did not resolve it)`
     );
   }
-  const add = await git(
-    ["worktree", "add", "-b", branchName, worktreePath, startPoint],
-    opts.repoPath,
-    { reject: false, timeoutMs: 6e4 }
-  );
-  if (add.exitCode !== 0) {
+  const added = await withRepoGitLock(opts.repoPath, async () => {
+    const add = await git(
+      ["worktree", "add", "-b", branchName, worktreePath, startPoint],
+      opts.repoPath,
+      { reject: false, timeoutMs: 6e4 }
+    );
+    if (add.exitCode === 0) return branchName;
     const err = `${add.stderr}
 ${add.stdout}`;
     if (/already used by worktree|already exists|checked out/i.test(err)) {
@@ -4524,17 +4606,14 @@ ${add.stdout}`;
           opts.repoPath,
           { reject: false, timeoutMs: 6e4 }
         );
-        if (retry.exitCode === 0) {
-          branchName = alt;
-          await ensureGhPreferOrigin(worktreePath);
-          return { branchName, worktreePath };
-        }
+        if (retry.exitCode === 0) return alt;
       }
     }
     throw new Error(
       `Failed to create worktree: ${add.stderr.trim() || add.stdout.trim() || `exit ${add.exitCode}`}`
     );
-  }
+  });
+  branchName = added;
   await ensureGhPreferOrigin(worktreePath);
   return { branchName, worktreePath };
 }
@@ -4558,12 +4637,13 @@ async function createExistingBranchWorktree(opts) {
     );
   }
   const startPoint = await resolveWorktreeStartPoint(opts.repoPath, branchName);
-  const add = await git(
-    ["worktree", "add", worktreePath, startPoint],
-    opts.repoPath,
-    { reject: false }
-  );
-  if (add.exitCode !== 0) {
+  await withRepoGitLock(opts.repoPath, async () => {
+    const add = await git(
+      ["worktree", "add", worktreePath, startPoint],
+      opts.repoPath,
+      { reject: false }
+    );
+    if (add.exitCode === 0) return;
     const retry = await git(
       ["worktree", "add", worktreePath, branchName],
       opts.repoPath,
@@ -4574,7 +4654,7 @@ async function createExistingBranchWorktree(opts) {
         `Failed to create worktree for ${branchName}: ${retry.stderr.trim() || add.stderr.trim() || retry.stdout.trim() || add.stdout.trim() || `exit ${add.exitCode}`}`
       );
     }
-  }
+  });
   const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
     reject: false
   });
@@ -4585,12 +4665,14 @@ async function createExistingBranchWorktree(opts) {
   return { branchName, worktreePath };
 }
 async function removeWorktree(repoPath, worktreePath, opts) {
-  await git(["worktree", "remove", "--force", worktreePath], repoPath, {
-    reject: false
+  await withRepoGitLock(repoPath, async () => {
+    await git(["worktree", "remove", "--force", worktreePath], repoPath, {
+      reject: false
+    });
+    if (opts?.deleteBranch) {
+      await git(["branch", "-D", opts.deleteBranch], repoPath, { reject: false });
+    }
   });
-  if (opts?.deleteBranch) {
-    await git(["branch", "-D", opts.deleteBranch], repoPath, { reject: false });
-  }
 }
 async function listWorktrees(repoPath) {
   const { stdout } = await git(
@@ -4882,6 +4964,7 @@ var init_worktree = __esm({
     init_gh_errors();
     init_git_auth_mode();
     init_run();
+    init_repo_git_lock();
     init_app_settings();
     init_pr_gates();
     init_stack();
@@ -4984,7 +5067,7 @@ function coordinatorGreenfieldPlaybook(reposDir) {
     "- Examples:",
     `  - Clone: \`git clone <url> ${reposDir}/<name>\``,
     `  - New GitHub repo: \`gh repo create <owner>/<name> --private --clone -- ${reposDir}/<name>\` (or mkdir + git init + gh repo create + remote add + push)`,
-    "- Then: add_workspace with that absolute path \u2192 create_thread (repoPath + parentThreadId) \u2192 send_to_thread (build) \u2192 wait_for_turn \u2192 ask_git create-draft (or send_to_thread `gh pr create --draft -R <origin-owner/name>`).",
+    "- Then: add_workspace with that absolute path \u2192 create_thread (repoPath + parentThreadId) \u2192 send_to_thread (build) \u2192 wait_for_turn (loop while stillRunning) \u2192 ask_git create-draft (or send_to_thread `gh pr create --draft -R <origin-owner/name>`).",
     "- Always target the child worktree's **origin** (`github:` slug from list_workspaces / `git remote get-url origin` in that worktree). Never open PRs against `upstream`.",
     "- Do coding work in the child worktree thread, not by editing files in this home cwd."
   ].join("\n");
@@ -5007,8 +5090,8 @@ 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.",
-    "- 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.",
+    "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn. If stillRunning, the child is working (progress is tools/thinking) \u2014 wait_for_turn again; do not ping it. 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 (loop while stillRunning) \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."
   ].filter(Boolean).join("\n");
@@ -5061,8 +5144,8 @@ function ensureGlobalCoordinatorCwd(opts) {
     orchId ? `Pass parentThreadId="${orchId}" (or omit it). Never invent another parentThreadId.` : "Pass `parentThreadId` for children (this chat's id from the turn reminder).",
     "Omit `agent` / `model` on `create_thread` unless you have a reason to override Account defaults.",
     "Never pass `agent=codex` when you yourself are Codex \u2014 nested Codex deadlocks on shared ~/.codex locks. Omit agent (Account default) or use cursor/claude.",
-    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 ask_git create-draft \u2192 wait_for_turn. Merge only if the user explicitly asked (`ask_git` merge).",
-    "Typical flow (new app): Bash create/clone under repos dir \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 ask_git create-draft.",
+    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn (loop while stillRunning) \u2192 ask_git create-draft \u2192 wait_for_turn. Merge only if the user explicitly asked (`ask_git` merge).",
+    "Typical flow (new app): Bash create/clone under repos dir \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn (loop while stillRunning) \u2192 ask_git create-draft.",
     "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 {
@@ -5130,7 +5213,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. wait_for_turn returns within ~45s even if the child is still working (MCP clients kill longer tool calls). If stillRunning is true, progress is a live snapshot of tools/thinking \u2014 call wait_for_turn again. Do not send \u201Care you stuck?\u201D or assume a hang while lastActivityAt is recent. 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:",
@@ -5138,8 +5221,8 @@ var init_coordinator_prompt = __esm({
       "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
       "Inspect / review / PRs:",
       "- get_diff \u2014 compact diff summary",
-      '- request_review \u2014 open a Review chat tab on a worktree thread (attaches .sideboard/review.md when present, else local guidelines; sends "Review changes in this workspace."); then wait_for_turn / get_turn_result on the returned id',
-      "- ask_git \u2014 commit & push, open a draft PR, resolve conflicts, or merge. When the worktree is clean, Sideboard pushes / opens the PR itself. When dirty, it queues the worktree agent \u2014 then wait_for_turn. Prefer this over paraphrasing.",
+      '- request_review \u2014 open a Review chat tab on a worktree thread (attaches .sideboard/review.md when present, else local guidelines; sends "Review changes in this workspace."); then wait_for_turn (loop while stillRunning) / get_turn_result on the returned id',
+      "- ask_git \u2014 commit & push, open a draft PR, resolve conflicts, or merge. When the worktree is clean, Sideboard pushes / opens the PR itself. When dirty, it queues the worktree agent \u2014 then wait_for_turn (loop while stillRunning). Prefer this over paraphrasing.",
       '- Merge (`ask_git` action=merge / send_to_thread "Merge PR.") only when the user explicitly asked to merge that PR. Do not merge because the work looks done, CI is green, or a typical flow includes it.',
       '- Or send_to_thread with those exact phrases: "Commit and push.", "Commit, push, and open a draft PR.", "Merge the remote branch (main) into your branch and resolve conflicts. Then, commit and push your changes.", "Merge PR." (draft PRs: `gh pr create --draft -R <origin-owner/name>` using the workspace `github:` slug \u2014 never upstream). Never run git/gh from this orchestration cwd, and never merge the PR yourself.',
       "Process guides:",
@@ -6046,6 +6129,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_fs18.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_fs18.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_fs18.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_fs18, import_node_path19;
+var init_packaged_runtime = __esm({
+  "src/agents/packaged-runtime.ts"() {
+    "use strict";
+    import_node_fs18 = require("fs");
+    import_node_path19 = require("path");
+  }
+});
+
 // src/agents/node-launch.ts
 function isAsarPath(filePath) {
   if (/\.asar\.unpacked([/\\]|$)/.test(filePath)) return false;
@@ -6055,24 +6187,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_fs19.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_path19.join)((0, import_node_os7.homedir)(), ".local/share/fnm/aliases/default/bin/node"),
-    (0, import_node_path19.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_fs19.existsSync)(root)) return [];
+  try {
+    return (0, import_node_fs19.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_fs19.existsSync)(p) || isElectronLikeCommand(p)) continue;
+    let key = p;
+    try {
+      key = (0, import_node_fs19.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 (path) => {
+      const version = await probeNodeVersion(path);
+      return version ? { path, version } : null;
+    })
+  );
+  return pickPreferredNode(probed.filter((c) => c != null));
 }
 function applyNodeLaunch(launch, args) {
   const readableArgs = args.map(nodeReadableScriptPath);
@@ -6090,9 +6327,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 {
@@ -6100,61 +6341,17 @@ async function resolveNodeLaunch(scriptPath) {
     env: { ELECTRON_RUN_AS_NODE: "1" }
   };
 }
-var import_node_fs18, import_node_os7, import_node_path19, WELL_KNOWN_NODE_BINS;
+var import_node_fs19, 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_fs19 = require("fs");
     import_node_os7 = require("os");
-    import_node_path19 = 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_path20.join)(resources, "cursor-runtime");
-  if (!(0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
-  return dir;
-}
-function packagedCursorRunnerPath() {
-  const dir = packagedCursorRuntimeDir();
-  return dir ? (0, import_node_path20.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
-}
-function packagedMcpDir() {
-  const resources = electronResourcesPath();
-  if (!resources) return null;
-  const dir = (0, import_node_path20.join)(resources, "sideboard-mcp");
-  if (!(0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
-  return dir;
-}
-function packagedMcpStdioPath() {
-  const dir = packagedMcpDir();
-  return dir ? (0, import_node_path20.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
-}
-function packagedCursorRipgrepCandidate(platformPkg, binName) {
-  const dir = packagedCursorRuntimeDir();
-  if (!dir) return null;
-  return (0, import_node_path20.join)(dir, "node_modules", platformPkg, "bin", binName);
-}
-var import_node_fs19, import_node_path20;
-var init_packaged_runtime = __esm({
-  "src/agents/packaged-runtime.ts"() {
-    "use strict";
-    import_node_fs19 = require("fs");
-    import_node_path20 = require("path");
+    init_packaged_runtime();
+    PREFERRED_LTS_MAJORS = [24, 22, 20];
   }
 });
 
@@ -8645,17 +8842,17 @@ __export(plan_file_exports, {
 });
 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");
+  if ((0, import_node_fs40.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs40.mkdirSync)((0, import_node_path36.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);
 }
 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;
@@ -8667,16 +8864,16 @@ function readPlanFile(worktreePath) {
 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_path36.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_path36;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs39 = require("fs");
+    import_node_fs40 = require("fs");
     import_node_path36 = require("path");
     init_workspace_scratch();
     init_plan_present();
@@ -8732,9 +8929,9 @@ function uniqueIds(ids) {
 }
 function readHold() {
   const path = caffeinateHoldPath();
-  if (!(0, import_node_fs40.existsSync)(path)) return null;
+  if (!(0, import_node_fs41.existsSync)(path)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs40.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs41.readFileSync)(path, "utf8"));
     if (typeof parsed?.pid === "number" && parsed.pid > 0) {
       return {
         pid: parsed.pid,
@@ -8756,7 +8953,7 @@ function writeHold(pid, threadIds) {
 }
 function clearHold() {
   try {
-    (0, import_node_fs40.unlinkSync)(caffeinateHoldPath());
+    (0, import_node_fs41.unlinkSync)(caffeinateHoldPath());
   } catch {
   }
 }
@@ -8841,12 +9038,12 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process4, import_node_fs40, import_node_path37, hooks;
+var import_node_child_process4, import_node_fs41, 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_fs40 = require("fs");
+    import_node_fs41 = require("fs");
     import_node_path37 = require("path");
     init_paths();
     init_private_file();
@@ -8863,9 +9060,9 @@ function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
   const runsPath = (0, import_node_path38.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs41.existsSync)(runsPath)) return null;
+  if (!(0, import_node_fs42.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs41.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs42.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -8891,11 +9088,11 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs41, import_node_path38;
+var import_node_fs42, import_node_path38;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs41 = require("fs");
+    import_node_fs42 = require("fs");
     import_node_path38 = require("path");
     init_paths();
   }
@@ -9419,7 +9616,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-var import_node_fs42 = require("fs");
+var import_node_fs43 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -9673,7 +9870,7 @@ function createAgentStreamCoalescer(emit, opts) {
   const intervalMs = opts?.intervalMs ?? 32;
   let pending = null;
   let timer = null;
-  const flush = () => {
+  const flush2 = () => {
     if (timer) {
       clearTimeout(timer);
       timer = null;
@@ -9685,13 +9882,13 @@ function createAgentStreamCoalescer(emit, opts) {
   };
   const schedule = () => {
     if (timer) return;
-    timer = setTimeout(flush, intervalMs);
+    timer = setTimeout(flush2, intervalMs);
     timer.unref?.();
   };
   return {
     push(event) {
       if (!isTextEvent(event)) {
-        flush();
+        flush2();
         emit(event);
         return;
       }
@@ -9699,12 +9896,12 @@ function createAgentStreamCoalescer(emit, opts) {
       if (pending && pending.type === event.type) {
         pending.data += event.data;
       } else {
-        flush();
+        flush2();
         pending = { type: event.type, data: event.data };
       }
       schedule();
     },
-    flush
+    flush: flush2
   };
 }
 
@@ -11020,8 +11217,11 @@ function worktreeBindingFrom(from) {
   };
 }
 function threadsSharingWorktree(worktreePath) {
+  if (!worktreePath) return [];
   const key = normalizeWorktreePath(worktreePath);
-  return listThreads({ includeArchived: true }).filter((t) => sameWorktreePath(t.worktreePath, key) && t.status !== "archived").sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return listThreads({ includeArchived: true }).filter(
+    (t) => Boolean(t.worktreePath) && sameWorktreePath(t.worktreePath, key) && t.status !== "archived"
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 function formatTranscriptMarkdown(title, messages) {
   const body = formatMessagesAsTranscript(messages, { tools: "full" });
@@ -11092,9 +11292,132 @@ function forkChatTab(input) {
   return tab;
 }
 
+// src/orchestrator/orchestrator.ts
+init_enqueue_by_key();
+init_run();
+init_repo_git_lock();
+
+// src/store/turn-live.ts
+var import_node_fs32 = require("fs");
+init_paths();
+var buffers = /* @__PURE__ */ new Map();
+var FLUSH_MS = 800;
+var MAX_PARTS = 80;
+function trimParts(parts) {
+  if (parts.length <= MAX_PARTS) return parts;
+  return parts.slice(-Math.floor(MAX_PARTS / 2));
+}
+function lastText(parts, type) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type === type && p.text.trim()) return p.text.trim();
+  }
+  return "";
+}
+function summarizeTurnLive(parts) {
+  const tools = parts.filter(
+    (p) => p.type === "tool"
+  );
+  const lastTool = tools[tools.length - 1];
+  const lastToolLabel = lastTool ? lastTool.description || toolDescription(lastTool.name, lastTool.input) || lastTool.name : void 0;
+  const running = lastTool?.status === "running";
+  const thinking = lastText(parts, "thinking");
+  const text3 = lastText(parts, "text");
+  const excerptRaw = thinking || text3;
+  const excerpt = excerptRaw.length > 280 ? `${excerptRaw.slice(-280)}` : excerptRaw || void 0;
+  let summary = "Working\u2026";
+  if (lastToolLabel) {
+    const verb = running ? lastToolLabel : `Finished ${lastToolLabel}`;
+    summary = tools.length > 1 ? `${verb} (${tools.length} tools)` : verb;
+  } else if (thinking) {
+    summary = "Thinking\u2026";
+  } else if (text3) {
+    summary = "Writing reply\u2026";
+  }
+  return {
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary,
+    lastTool: lastToolLabel,
+    toolCount: tools.length,
+    excerpt
+  };
+}
+function flush(threadId) {
+  const buf = buffers.get(threadId);
+  if (!buf) return;
+  if (buf.timer) {
+    clearTimeout(buf.timer);
+    buf.timer = null;
+  }
+  writeTurnLive(threadId, summarizeTurnLive(buf.parts));
+}
+function scheduleFlush(threadId) {
+  const buf = buffers.get(threadId);
+  if (!buf) return;
+  if (buf.timer) return;
+  buf.timer = setTimeout(() => {
+    const live = buffers.get(threadId);
+    if (live) live.timer = null;
+    flush(threadId);
+  }, FLUSH_MS);
+}
+function noteTurnLiveEvent(threadId, event) {
+  if (event.type === "session_id" || event.type === "usage" || event.type === "stderr") {
+    return;
+  }
+  const prev = buffers.get(threadId) ?? { parts: [], timer: null };
+  prev.parts = trimParts(applyAgentEvent(prev.parts, event));
+  buffers.set(threadId, prev);
+  if (event.type === "exit") {
+    flush(threadId);
+    const cur = buffers.get(threadId);
+    if (cur?.timer) clearTimeout(cur.timer);
+    buffers.delete(threadId);
+    return;
+  }
+  const immediate = event.type === "tool_use" || event.type === "tool_result";
+  if (immediate) flush(threadId);
+  else scheduleFlush(threadId);
+}
+function writeTurnLive(threadId, progress) {
+  const path = threadLivePath(threadId);
+  const tmp = `${path}.${process.pid}.tmp`;
+  try {
+    (0, import_node_fs32.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs32.renameSync)(tmp, path);
+  } catch {
+    try {
+      (0, import_node_fs32.unlinkSync)(tmp);
+    } catch {
+    }
+  }
+}
+function readTurnLive(threadId) {
+  const path = threadLivePath(threadId);
+  if (!(0, import_node_fs32.existsSync)(path)) return null;
+  try {
+    const raw = JSON.parse((0, import_node_fs32.readFileSync)(path, "utf8"));
+    if (!raw || typeof raw.summary !== "string") return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function clearTurnLive(threadId) {
+  const buf = buffers.get(threadId);
+  if (buf?.timer) clearTimeout(buf.timer);
+  buffers.delete(threadId);
+  const path = threadLivePath(threadId);
+  if (!(0, import_node_fs32.existsSync)(path)) return;
+  try {
+    (0, import_node_fs32.unlinkSync)(path);
+  } catch {
+  }
+}
+
 // src/review/request-review.ts
 var import_node_crypto5 = require("crypto");
-var import_node_fs32 = require("fs");
+var import_node_fs33 = require("fs");
 var import_node_path30 = require("path");
 init_global_workspace();
 init_thread_store();
@@ -11243,9 +11566,9 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs32.existsSync)(abs)) return null;
+  if (!(0, import_node_fs33.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs32.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs33.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
@@ -11253,9 +11576,9 @@ function readTextIfPresent(abs) {
 }
 function ensureAttachmentsGitignore(worktreePath) {
   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");
+  if ((0, import_node_fs33.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs33.mkdirSync)((0, import_node_path30.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs33.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = (0, import_node_path30.join)(worktreePath, REPO_REVIEW_PATH);
@@ -11289,8 +11612,8 @@ function resolveReviewGuidelines(worktreePath) {
     };
   }
   ensureAttachmentsGitignore(worktreePath);
-  (0, import_node_fs32.mkdirSync)((0, import_node_path30.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs32.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs33.mkdirSync)((0, import_node_path30.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs33.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -11490,7 +11813,7 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 
 // src/threads/adopt.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs33 = require("fs");
+var import_node_fs34 = require("fs");
 var import_node_os10 = require("os");
 var import_node_path31 = require("path");
 var import_node_module4 = require("module");
@@ -11521,21 +11844,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_path31.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs33.existsSync)(agentsFile)) continue;
+    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;
     }
@@ -11559,7 +11882,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);
@@ -11583,18 +11906,18 @@ async function adoptThread(input) {
   return thread;
 }
 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_path31.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const tmp = (0, import_node_fs34.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_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 {
         }
       }
@@ -11670,22 +11993,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_path31.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const tmp = (0, import_node_fs34.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_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 {
         }
       }
@@ -11703,7 +12026,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;
@@ -11766,7 +12089,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) {
@@ -11774,7 +12097,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-var import_node_fs34 = require("fs");
+var import_node_fs35 = require("fs");
 init_run();
 init_stack();
 init_worktree();
@@ -11842,7 +12165,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_fs34.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs35.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -11984,7 +12307,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_fs34.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs35.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);
@@ -12051,7 +12374,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs34.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs35.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -12066,12 +12389,12 @@ async function createPrStack(input, onSetupLine) {
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs35 = require("fs");
+var import_node_fs36 = require("fs");
 var import_node_path32 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs35.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs36.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -12079,7 +12402,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs35.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs36.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -12217,9 +12540,9 @@ new file mode 100644
 async function untrackedPatch(worktreePath, path, maxHunk) {
   const abs = (0, import_node_path32.join)(worktreePath, path);
   try {
-    const st = (0, import_node_fs35.statSync)(abs);
+    const st = (0, import_node_fs36.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs35.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs36.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -12721,7 +13044,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
   const abs = (0, import_node_path32.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs35.statSync)(abs);
+  const st = (0, import_node_fs36.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -12730,7 +13053,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs35.readFileSync)(abs);
+  const buf = (0, import_node_fs36.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -12741,11 +13064,11 @@ function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
   const abs = (0, import_node_path32.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs35.statSync)(abs);
+  const st = (0, import_node_fs36.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs35.readFileSync)(abs);
+  const buf = (0, import_node_fs36.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -12789,8 +13112,8 @@ function assertSafeRelativePath(relativePath) {
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
   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");
+  (0, import_node_fs36.mkdirSync)((0, import_node_path32.dirname)(abs), { recursive: true });
+  (0, import_node_fs36.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -12894,7 +13217,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs36 = require("fs");
+var import_node_fs37 = require("fs");
 var import_node_os11 = require("os");
 var import_node_path33 = require("path");
 function toCommand(name) {
@@ -12928,7 +13251,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs36.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs37.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -12947,19 +13270,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs36.existsSync)(dir)) return;
+  if (!(0, import_node_fs37.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs36.readdirSync)(dir);
+    entries = (0, import_node_fs37.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
     const skillMd = (0, import_node_path33.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs36.existsSync)(skillMd)) continue;
+    if (!(0, import_node_fs37.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs36.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs37.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -12968,12 +13291,12 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs36.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs37.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs36.readdirSync)(dir);
+      entries = (0, import_node_fs37.readdirSync)(dir);
     } catch {
       return;
     }
@@ -12985,7 +13308,7 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       if (entry === "node_modules" || entry === ".git") continue;
       const full = (0, import_node_path33.join)(dir, entry);
       try {
-        if (!(0, import_node_fs36.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs37.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -13025,7 +13348,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_fs36.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs37.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -13118,7 +13441,7 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs37 = require("fs");
+var import_node_fs38 = require("fs");
 var import_node_path34 = require("path");
 var import_node_crypto7 = require("crypto");
 init_workspace_scratch();
@@ -13156,21 +13479,21 @@ function imageMimeType(filePath) {
 }
 function ensureAttachmentsDir(worktreePath) {
   const dir = (0, import_node_path34.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs37.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs38.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");
+  if (!(0, import_node_fs38.existsSync)(gi)) {
+    (0, import_node_fs38.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs37.existsSync)((0, import_node_path34.join)(dir, safe))) return safe;
+  if (!(0, import_node_fs38.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_fs37.existsSync)((0, import_node_path34.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs38.existsSync)((0, import_node_path34.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto7.randomUUID)()}${ext}`;
 }
@@ -13228,13 +13551,13 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   for (const abs of absolutePaths) {
     const originalName = (0, import_node_path34.basename)(abs);
     try {
-      const st = (0, import_node_fs37.statSync)(abs);
+      const st = (0, import_node_fs38.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
       const destAbs = (0, import_node_path34.join)(dir, name);
-      (0, import_node_fs37.copyFileSync)(abs, destAbs);
+      (0, import_node_fs38.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs37.readFileSync)(destAbs);
+      const buf = (0, import_node_fs38.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13247,17 +13570,17 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   }
   return out;
 }
-function stageBuffersAsAttachments(worktreePath, buffers) {
-  if (buffers.length === 0) return [];
+function stageBuffersAsAttachments(worktreePath, buffers2) {
+  if (buffers2.length === 0) return [];
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
-  for (const item of buffers) {
+  for (const item of buffers2) {
     const originalName = (item.name || "file").replace(/[/\\]/g, "_") || "file";
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
       const destAbs = (0, import_node_path34.join)(dir, name);
-      (0, import_node_fs37.writeFileSync)(destAbs, buf);
+      (0, import_node_fs38.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -13286,9 +13609,9 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     const name = (0, import_node_path34.basename)(rel);
     try {
       const abs = (0, import_node_path34.join)(worktreePath, rel);
-      const st = (0, import_node_fs37.statSync)(abs);
+      const st = (0, import_node_fs38.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs37.readFileSync)(abs);
+      const buf = (0, import_node_fs38.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13303,7 +13626,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-var import_node_fs38 = require("fs");
+var import_node_fs39 = require("fs");
 var import_node_path35 = require("path");
 init_git_auth_mode();
 init_worktree_labels();
@@ -13507,6 +13830,15 @@ function isPidAlive(pid) {
     return false;
   }
 }
+async function waitForPidExit(pid, timeoutMs) {
+  const start = Date.now();
+  while (isPidAlive(pid)) {
+    if (Date.now() - start >= timeoutMs) return false;
+    await new Promise((r) => setTimeout(r, 80));
+  }
+  return true;
+}
+var STALE_AGENT_PID_WAIT_MS = 2500;
 function writeLiveStatus(threadId, status, lastError) {
   const latest = readThread(threadId);
   if (!latest || latest.status === "archived") return latest;
@@ -13584,7 +13916,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs42.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs43.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -13905,14 +14237,10 @@ var Orchestrator = class {
     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) {
+    if (inFlight || foreignLive) {
       this.stop(thread.id, { clearQueue: false, continueQueue: true });
-    } else {
-      if (foreignLive) {
-        this.stop(thread.id, { clearQueue: false, continueQueue: true });
-      }
-      void this.drainQueue(thread.id);
     }
+    void this.drainQueue(thread.id);
     return this.requireThread(thread.id);
   }
   async drainQueue(threadId) {
@@ -13941,7 +14269,18 @@ var Orchestrator = class {
         }
         const livePid = thread.agentPid;
         if (typeof livePid === "number" && livePid > 0 && isPidAlive(livePid)) {
-          await new Promise((r) => setTimeout(r, 200));
+          const exited = await waitForPidExit(livePid, STALE_AGENT_PID_WAIT_MS);
+          if (!exited && isPidAlive(livePid)) {
+            try {
+              process.kill(livePid, "SIGKILL");
+            } catch {
+            }
+            await waitForPidExit(livePid, 400);
+            try {
+              updateThread(threadId, { agentPid: null });
+            } catch {
+            }
+          }
           continue;
         }
         const prompt = thread.queue[0];
@@ -14098,6 +14437,7 @@ var Orchestrator = class {
         { cachedPrefix, prompt: agentPrompt },
         (event) => {
           this.emit({ type: "turn_output", threadId, event });
+          noteTurnLiveEvent(threadId, event);
           if (event.type === "session_id") {
             updateThread(threadId, { sessionId: event.data });
           }
@@ -14161,19 +14501,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);
@@ -14222,10 +14559,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",
@@ -14308,6 +14642,7 @@ var Orchestrator = class {
       this.processes.delete(`${threadId}:agent`);
       this.stoppedTurns.delete(threadId);
       this.runningCount = Math.max(0, this.runningCount - 1);
+      clearTurnLive(threadId);
       try {
         updateThread(threadId, { agentPid: null });
       } catch {
@@ -14581,51 +14916,56 @@ var Orchestrator = class {
     }
     return created;
   }
-  async waitForTurn(threadRef, timeoutMs = 6e5) {
+  async waitForTurn(threadRef, timeoutMs = 6e5, opts) {
     const thread = this.requireThread(threadRef);
+    if (!["running", "queued"].includes(thread.status)) {
+      return thread;
+    }
     const start = Date.now();
     return new Promise((resolve, reject) => {
-      if (!["running", "queued"].includes(thread.status)) {
-        resolve(thread);
-        return;
-      }
+      let settled = false;
+      let timer;
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearInterval(timer);
+        off();
+        fn();
+      };
       const off = this.on((event) => {
         if (event.type === "turn_finished" && event.threadId === thread.id) {
-          off();
           const latest = readThread(thread.id);
           if (!latest) {
-            reject(new Error(`Thread not found: ${thread.id}`));
+            finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
             return;
           }
-          resolve(latest);
+          finish(() => resolve(latest));
         }
         if (event.type === "error" && event.threadId === thread.id) {
-          off();
           const latest = readThread(thread.id);
           if (!latest) {
-            reject(new Error(`Thread not found: ${thread.id}`));
+            finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
             return;
           }
-          resolve(latest);
+          finish(() => resolve(latest));
         }
       });
-      const timer = setInterval(() => {
-        if (Date.now() - start > timeoutMs) {
-          clearInterval(timer);
-          off();
-          reject(new Error("wait_for_turn timed out"));
-        }
+      timer = setInterval(() => {
         const current = readThread(thread.id);
         if (!current) {
-          clearInterval(timer);
-          off();
-          reject(new Error(`Thread not found: ${thread.id}`));
+          finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
           return;
         }
         if (!["running", "queued"].includes(current.status)) {
-          clearInterval(timer);
-          off();
-          resolve(current);
+          finish(() => resolve(current));
+          return;
+        }
+        if (Date.now() - start > timeoutMs) {
+          if (opts?.resolveIfStillRunning) {
+            finish(() => resolve(current));
+          } else {
+            finish(() => reject(new Error("wait_for_turn timed out")));
+          }
         }
       }, 200);
     });
@@ -14633,10 +14973,18 @@ 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 ?? "" : "");
+    const stillRunning = thread.status === "running" || thread.status === "queued";
+    const live = stillRunning ? readTurnLive(thread.id) : null;
     return {
-      text: lastAgent?.text ?? "",
+      text: text3,
       status: thread.status,
-      sessionId: thread.sessionId
+      sessionId: thread.sessionId,
+      lastError,
+      stillRunning,
+      progress: live?.summary ?? null,
+      lastActivityAt: live?.updatedAt ?? null
     };
   }
   assertNotGlobal(thread, action) {
@@ -15062,7 +15410,19 @@ var Orchestrator = class {
     const thread = this.requireThread(threadRef);
     return threadsSharingWorktree(thread.worktreePath);
   }
+  /**
+   * Last-tab teardown must see siblings already archived. Serialize per
+   * worktree so parallel archive/purge of sibling tabs still removes once.
+   */
+  enqueueWorktreeTeardown(thread, fn) {
+    const key = isGlobalThread(thread) ? `archive:global:${thread.id}` : `archive:wt:${normalizeWorktreePath(thread.worktreePath)}`;
+    return enqueueByKey(key, fn);
+  }
   async archive(threadRef) {
+    const thread = this.requireThread(threadRef);
+    return this.enqueueWorktreeTeardown(thread, () => this.archiveUnlocked(threadRef));
+  }
+  async archiveUnlocked(threadRef) {
     const thread = this.requireThread(threadRef);
     this.stop(thread.id);
     this.releaseOrchestratorCaffeinate(thread);
@@ -15098,6 +15458,10 @@ var Orchestrator = class {
     return archived;
   }
   async purge(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    await this.enqueueWorktreeTeardown(thread, () => this.purgeUnlocked(threadRef, opts));
+  }
+  async purgeUnlocked(threadRef, opts) {
     const thread = this.requireThread(threadRef);
     this.stop(thread.id);
     this.releaseOrchestratorCaffeinate(thread);
@@ -15132,13 +15496,12 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!(0, import_node_fs42.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs43.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();
       const dest = thread.worktreePath;
-      await execa7("git", ["worktree", "add", dest, thread.branchName], {
-        cwd: thread.repoPath
+      await withRepoGitLock(thread.repoPath, async () => {
+        await git(["worktree", "add", dest, thread.branchName], thread.repoPath);
       });
       void createThreadWorktree2;
       void slug;
@@ -15702,6 +16065,15 @@ function mcpArchiveBlockedReason(thread) {
 // src/mcp/server.ts
 init_profile();
 
+// src/mcp/wait-for-turn.ts
+var MCP_WAIT_FOR_TURN_MAX_MS = 45e3;
+function mcpWaitForTurnTimeoutMs(requested) {
+  const n = requested ?? MCP_WAIT_FOR_TURN_MAX_MS;
+  if (!Number.isFinite(n)) return MCP_WAIT_FOR_TURN_MAX_MS;
+  return Math.min(Math.max(1e3, Math.floor(n)), MCP_WAIT_FOR_TURN_MAX_MS);
+}
+var MCP_WAIT_STILL_RUNNING_HINT = "Child is still working. Call wait_for_turn again. Do not send a check-in prompt or assume a hang while progress is updating.";
+
 // src/mcp/slack-tools.ts
 var import_zod = require("zod");
 
@@ -16373,7 +16745,9 @@ async function startMcpServer() {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
         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}` : ""}`;
+        const live = t.status === "running" || t.status === "queued" ? readTurnLive(t.id) : null;
+        const progress = live?.summary ? `  ${live.summary}` : "";
+        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}` : ""}${progress}`;
       });
       return {
         content: [{ type: "text", text: lines.join("\n") || "(no threads)" }]
@@ -16382,13 +16756,14 @@ async function startMcpServer() {
   );
   server.tool(
     "get_thread",
-    "Get a compact thread summary by id/ref",
+    "Get a compact thread summary by id/ref. While running, includes progress (last tool/thinking) and lastActivityAt.",
     { ref: import_zod3.z.string() },
     async ({ ref }) => {
       const t = orch.getThread(ref);
       if (!t) {
         return { content: [{ type: "text", text: `Thread not found: ${ref}` }], isError: true };
       }
+      const live = t.status === "running" || t.status === "queued" ? readTurnLive(t.id) : null;
       const summary = {
         id: t.id,
         title: t.title,
@@ -16403,7 +16778,10 @@ async function startMcpServer() {
         messageCount: t.messages.length,
         devPort: t.devPort,
         prUrl: t.prUrl,
-        lastError: t.lastError ?? null
+        lastError: t.lastError ?? null,
+        stillRunning: t.status === "running" || t.status === "queued",
+        progress: live?.summary ?? null,
+        lastActivityAt: live?.updatedAt ?? null
       };
       return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
     }
@@ -16729,13 +17107,15 @@ 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.",
+      "Wait until the thread finishes its current/queued turn, or return early with a live progress snapshot. MCP clients often kill tools around 60s, so this returns within 45s even while the child is still working. If stillRunning is true, progress is tools/thinking \u2014 call wait_for_turn again. Do not send a check-in prompt or assume a hang. On status error, lastError/text is the failure.",
       {
         ref: import_zod3.z.string(),
         timeoutMs: import_zod3.z.number().optional()
       },
       async ({ ref, timeoutMs }) => {
-        const thread = await orch.waitForTurn(ref, timeoutMs ?? 6e5);
+        const thread = await orch.waitForTurn(ref, mcpWaitForTurnTimeoutMs(timeoutMs), {
+          resolveIfStillRunning: true
+        });
         const result = orch.getTurnResult(thread.id);
         return {
           content: [
@@ -16744,7 +17124,12 @@ async function startMcpServer() {
               text: JSON.stringify({
                 id: thread.id,
                 status: result.status,
-                text: result.text
+                text: result.text,
+                lastError: result.lastError,
+                stillRunning: result.stillRunning,
+                progress: result.progress,
+                lastActivityAt: result.lastActivityAt,
+                hint: result.stillRunning ? MCP_WAIT_STILL_RUNNING_HINT : void 0
               })
             }
           ]
@@ -16753,11 +17138,21 @@ async function startMcpServer() {
     );
     server.tool(
       "get_turn_result",
-      "Final assistant message only (not full transcript)",
+      "Assistant message when the turn finished, or live progress while stillRunning. Not the full transcript.",
       { ref: import_zod3.z.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
-        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ...result,
+                hint: result.stillRunning ? MCP_WAIT_STILL_RUNNING_HINT : void 0
+              })
+            }
+          ]
+        };
       }
     );
     server.tool(
@@ -16874,7 +17269,7 @@ async function startMcpServer() {
     );
     server.tool(
       "request_review",
-      'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.',
+      'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn (loop while stillRunning) / get_turn_result on the returned review tab id.',
       { ref: import_zod3.z.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
@@ -16902,7 +17297,7 @@ async function startMcpServer() {
     );
     server.tool(
       "ask_git",
-      "Commit & push, open a draft PR, resolve conflicts, or merge \u2014 same actions as the desktop git buttons. When the worktree is clean, Sideboard pushes / opens the PR itself (HTTPS via `gh` if SSH is missing). When dirty, queues the worktree agent to commit; then wait_for_turn. Pass a worktree thread ref (not the orchestrator). action=merge only when the user explicitly asked to merge that PR. Do not run git or gh from the orchestration cwd.",
+      "Commit & push, open a draft PR, resolve conflicts, or merge \u2014 same actions as the desktop git buttons. When the worktree is clean, Sideboard pushes / opens the PR itself (HTTPS via `gh` if SSH is missing). When dirty, queues the worktree agent to commit; then wait_for_turn (loop while stillRunning). Pass a worktree thread ref (not the orchestrator). action=merge only when the user explicitly asked to merge that PR. Do not run git or gh from the orchestration cwd.",
       {
         ref: import_zod3.z.string().describe("Worktree thread id/ref"),
         action: import_zod3.z.enum(AGENT_GIT_ACTIONS).describe(
@@ -16953,7 +17348,7 @@ async function startMcpServer() {
     );
     server.tool(
       "fork_worktree",
-      "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn on the returned id.",
+      "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn (loop while stillRunning) on the returned id.",
       {
         ref: import_zod3.z.string().describe("Worktree thread id/ref to fork"),
         through_index: import_zod3.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
@@ -16998,7 +17393,7 @@ async function startMcpServer() {
     );
     server.tool(
       "fork_chat",
-      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Slack / Global orchestrators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
+      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Slack / Global orchestrators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn (loop while stillRunning) on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
       {
         ref: import_zod3.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
         through_index: import_zod3.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),