@sideboard-ai/core 0.1.100 → 0.1.103

package/dist/mcp/run-stdio.js

@@ -18,14 +18,14 @@ import {
   sideboardMcpProfile,
   summarizeTurnStderr,
   turnFailChatText
-} from "../chunk-EQPQTLW6.js";
-import "../chunk-DKHGWYWR.js";
+} from "../chunk-LANDJIAI.js";
+import "../chunk-7YKXHBIW.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "../chunk-MRBKGFTL.js";
+} from "../chunk-ND6AO7C5.js";
 import {
   extractPresentedPlan,
   readPlanFile,
@@ -33,7 +33,7 @@ import {
 } from "../chunk-N5PM7HGQ.js";
 import {
   releaseCaffeinateHoldForThread
-} from "../chunk-7KDBDMNC.js";
+} from "../chunk-KLBOWJ74.js";
 import {
   GLOBAL_WORKSPACE_ID,
   assertOrchestratorCapableAgent,
@@ -44,14 +44,14 @@ import {
   isOrchestratorThread,
   isSlackCoordinatorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "../chunk-WQTTUC4N.js";
+} from "../chunk-OW34MVDN.js";
 import {
   SLACK_REPLY_FORMATTING,
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "../chunk-IFHKPZHA.js";
+} from "../chunk-YJADJH5U.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -62,6 +62,7 @@ import {
   createThreadWorktree,
   currentBranch,
   detectGhStack,
+  enqueueByKey,
   fetchPrHead,
   formatGhLandError,
   formatGitAuthModeDirective,
@@ -94,8 +95,9 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   warmGithubAgentAuth,
+  withRepoGitLock,
   worktreeNameFromPath
-} from "../chunk-R7BQBSDT.js";
+} from "../chunk-WA3DVVWG.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -112,7 +114,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "../chunk-JOF3XIEM.js";
+} from "../chunk-P3BQ5DOL.js";
 import {
   childEnvWithAppSettings,
   disconnectLinearConnection,
@@ -130,7 +132,7 @@ import {
   stripNestedElectronEnv,
   updateAdvancedSettings,
   writeSecureJson
-} from "../chunk-6LFV4VFI.js";
+} from "../chunk-WSYCND2U.js";
 import {
   writePrivateFile
 } from "../chunk-NSTQ6QKD.js";
@@ -143,9 +145,10 @@ import {
   runCursorWorktreeSetup,
   sideboardReposDir,
   sideboardWorkspacesDir,
+  threadLivePath,
   workspaceSettingsSourceLabel,
   worktreesRoot
-} from "../chunk-JL4SJ6V7.js";
+} from "../chunk-BD2ICC4D.js";
 import {
   enrichPathWithNpmGlobalBin,
   ensureAgentPath,
@@ -660,7 +663,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 
 // src/agents/spawn.ts
 import { createInterface } from "readline";
@@ -902,7 +905,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;
@@ -914,13 +917,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;
       }
@@ -928,12 +931,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
   };
 }
 
@@ -945,9 +948,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-YZWYHLQY.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-KJQS5S2C.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-OOBSQCWQ.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-3DFZRMXE.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1888,7 +1891,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-CLP5BG4O.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-UT5GCJH3.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2213,8 +2216,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" });
@@ -2285,9 +2291,132 @@ function forkChatTab(input) {
   return tab;
 }
 
+// src/store/turn-live.ts
+import {
+  existsSync as existsSync7,
+  renameSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync5
+} from "fs";
+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 {
+    writeFileSync2(tmp, JSON.stringify(progress), "utf8");
+    renameSync(tmp, path);
+  } catch {
+    try {
+      unlinkSync2(tmp);
+    } catch {
+    }
+  }
+}
+function readTurnLive(threadId) {
+  const path = threadLivePath(threadId);
+  if (!existsSync7(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync5(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 (!existsSync7(path)) return;
+  try {
+    unlinkSync2(path);
+  } catch {
+  }
+}
+
 // src/review/request-review.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2, join as join8 } from "path";
 
 // src/review/review-request-template.ts
@@ -2433,9 +2562,9 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!existsSync7(abs)) return null;
+  if (!existsSync8(abs)) return null;
   try {
-    const content = readFileSync5(abs, "utf8");
+    const content = readFileSync6(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
@@ -2443,9 +2572,9 @@ function readTextIfPresent(abs) {
 }
 function ensureAttachmentsGitignore(worktreePath) {
   const gitignoreAbs = join8(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if (existsSync7(gitignoreAbs)) return;
+  if (existsSync8(gitignoreAbs)) return;
   mkdirSync2(dirname2(gitignoreAbs), { recursive: true });
-  writeFileSync2(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  writeFileSync3(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = join8(worktreePath, REPO_REVIEW_PATH);
@@ -2480,7 +2609,7 @@ function resolveReviewGuidelines(worktreePath) {
   }
   ensureAttachmentsGitignore(worktreePath);
   mkdirSync2(dirname2(localAbs), { recursive: true });
-  writeFileSync2(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  writeFileSync3(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -2676,10 +2805,10 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 import { execFileSync } from "child_process";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
@@ -2709,7 +2838,7 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync8(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync9(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
@@ -2720,10 +2849,10 @@ function resolveConductorCursorAgentId(workspacePath) {
   }
   for (const hash of hashes) {
     const agentsFile = join9(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync8(agentsFile)) continue;
+    if (!existsSync9(agentsFile)) continue;
     let text3;
     try {
-      text3 = readFileSync6(agentsFile, "utf8");
+      text3 = readFileSync7(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -2747,7 +2876,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync8(input.worktreePath)) {
+  if (!existsSync9(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -2766,12 +2895,12 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-ENVUDK6C.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-NTIVI6DI.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!existsSync8(CONDUCTOR_DB)) {
+  if (!existsSync9(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
   const tmp = mkdtempSync(join9(tmpdir(), "sideboard-conductor-"));
@@ -2780,7 +2909,7 @@ function listConductorWorkspaces() {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync8(src)) {
+      if (existsSync9(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -2862,7 +2991,7 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync8(CONDUCTOR_DB)) {
+  if (!existsSync9(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
   const tmp = mkdtempSync(join9(tmpdir(), "sideboard-conductor-"));
@@ -2871,7 +3000,7 @@ function importConductorWorkspace(workspaceId) {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync8(src)) {
+      if (existsSync9(src)) {
         try {
           copyFileSync2(src, `${snapshot}${suffix}`);
         } catch {
@@ -2891,7 +3020,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync8(worktreePath)) {
+      if (!existsSync9(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -2962,7 +3091,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function stackIdFrom(stack) {
   if (stack.stackNumber != null) return `gh-stack-${stack.stackNumber}`;
   const key = stack.layers.map((l) => l.branchName).join("|");
@@ -3025,7 +3154,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 && existsSync9(checkedOut.path)) {
+  if (checkedOut?.path && existsSync10(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -3167,7 +3296,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync9(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!existsSync10(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);
@@ -3234,7 +3363,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && existsSync9(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && existsSync10(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -3246,10 +3375,10 @@ async function createPrStack(input, onSetupLine) {
 }
 
 // src/diff/diff.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname3, join as join10 } from "path";
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !existsSync10(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !existsSync11(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -3257,7 +3386,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !existsSync10(worktreePath)) {
+  if (!worktreePath || !existsSync11(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -3397,7 +3526,7 @@ async function untrackedPatch(worktreePath, path, maxHunk) {
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = readFileSync7(abs).subarray(0, maxHunk);
+      const buf = readFileSync8(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -3908,7 +4037,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = readFileSync7(abs);
+  const buf = readFileSync8(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -3923,7 +4052,7 @@ function readWorktreeFile(worktreePath, relativePath, opts) {
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = readFileSync7(abs);
+  const buf = readFileSync8(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -3968,7 +4097,7 @@ function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
   const abs = join10(worktreePath, relativePath);
   mkdirSync3(dirname3(abs), { recursive: true });
-  writeFileSync3(abs, content, "utf8");
+  writeFileSync4(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -4071,7 +4200,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
 import { homedir } from "os";
 import { join as join11 } from "path";
 function toCommand(name) {
@@ -4105,7 +4234,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = readFileSync8(skillMd, "utf8");
+    const content = readFileSync9(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -4124,7 +4253,7 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync11(dir)) return;
+  if (!existsSync12(dir)) return;
   let entries;
   try {
     entries = readdirSync4(dir);
@@ -4134,7 +4263,7 @@ function scanSkillsDir(dir, source, out) {
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
     const skillMd = join11(dir, entry, "SKILL.md");
-    if (!existsSync11(skillMd)) continue;
+    if (!existsSync12(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
     } catch {
@@ -4145,7 +4274,7 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!existsSync11(pluginsRoot)) return;
+  if (!existsSync12(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
@@ -4202,7 +4331,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = readFileSync8(skillPath, "utf8");
+  const raw = readFileSync9(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -4295,7 +4424,7 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync9, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
+import { copyFileSync as copyFileSync3, existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync10, statSync as statSync4, writeFileSync as writeFileSync5 } from "fs";
 import { basename as basename3, extname, join as join12 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -4334,19 +4463,19 @@ function ensureAttachmentsDir(worktreePath) {
   const dir = join12(worktreePath, ATTACHMENTS_DIR);
   mkdirSync4(dir, { recursive: true });
   const gi = join12(dir, ".gitignore");
-  if (!existsSync12(gi)) {
-    writeFileSync4(gi, attachmentsGitignoreBody(), "utf8");
+  if (!existsSync13(gi)) {
+    writeFileSync5(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!existsSync12(join12(dir, safe))) return safe;
+  if (!existsSync13(join12(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 (!existsSync12(join12(dir, candidate))) return candidate;
+    if (!existsSync13(join12(dir, candidate))) return candidate;
   }
   return `${stem}-${randomUUID4()}${ext}`;
 }
@@ -4410,7 +4539,7 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
       const destAbs = join12(dir, name);
       copyFileSync3(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = readFileSync9(destAbs);
+      const buf = readFileSync10(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -4423,17 +4552,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 = join12(dir, name);
-      writeFileSync4(destAbs, buf);
+      writeFileSync5(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -4464,7 +4593,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
       const abs = join12(worktreePath, rel);
       const st = statSync4(abs);
       if (!st.isFile()) continue;
-      const buf = readFileSync9(abs);
+      const buf = readFileSync10(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -4479,7 +4608,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, statSync as statSync5 } from "fs";
 import { join as join13 } from "path";
 function normPath(p) {
   return p.replace(/\/+$/, "");
@@ -4669,6 +4798,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;
@@ -4746,7 +4884,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync14(thread.worktreePath)) {
+      if (!existsSync15(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -4765,7 +4903,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("../app-settings-ZXPAB3QN.js");
+      const { autoCleanupOrphansEnabled } = await import("../app-settings-VDJK2BZ2.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -4933,7 +5071,7 @@ var Orchestrator = class {
       }
     }
     await setup;
-    const { autoRunAfterSetupEnabled } = await import("../app-settings-ZXPAB3QN.js");
+    const { autoRunAfterSetupEnabled } = await import("../app-settings-VDJK2BZ2.js");
     if (autoRunAfterSetupEnabled()) {
       try {
         await this.startDev(threadId);
@@ -5067,14 +5205,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) {
@@ -5103,7 +5237,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];
@@ -5211,7 +5356,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("../app-settings-ZXPAB3QN.js");
+    const { autoRenameBranchEnabled, getGithubGitAuthMode } = await import("../app-settings-VDJK2BZ2.js");
     const gitAuthMode = getGithubGitAuthMode();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -5260,6 +5405,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 });
           }
@@ -5306,7 +5452,7 @@ var Orchestrator = class {
       if (this.requireThread(threadId).agent === "cursor" && exitCode !== 0 && !assistantText && parts.length === 0) {
         const sessionId = result.sessionId || this.requireThread(threadId).sessionId || "";
         if (sessionId) {
-          const { recoverFinishedCursorRun } = await import("../cursor-recover-S5ORPW34.js");
+          const { recoverFinishedCursorRun } = await import("../cursor-recover-JBTIDARH.js");
           for (let i = 0; i < 8; i++) {
             const recovered = recoverFinishedCursorRun({
               agentId: sessionId,
@@ -5464,6 +5610,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 {
@@ -5737,51 +5884,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);
     });
@@ -5791,11 +5943,16 @@ var Orchestrator = class {
     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: text3,
       status: thread.status,
       sessionId: thread.sessionId,
-      lastError
+      lastError,
+      stillRunning,
+      progress: live?.summary ?? null,
+      lastActivityAt: live?.updatedAt ?? null
     };
   }
   assertNotGlobal(thread, action) {
@@ -5958,7 +6115,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("../app-settings-ZXPAB3QN.js");
+    const { autoArchiveOnMergeEnabled } = await import("../app-settings-VDJK2BZ2.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -6221,7 +6378,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);
@@ -6249,7 +6418,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-ENVUDK6C.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-NTIVI6DI.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -6257,6 +6426,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);
@@ -6271,7 +6444,7 @@ var Orchestrator = class {
         await runArchiveScript(thread.repoPath, thread.worktreePath);
       } catch {
       }
-      const { deleteBranchOnPurgeEnabled } = await import("../app-settings-ZXPAB3QN.js");
+      const { deleteBranchOnPurgeEnabled } = await import("../app-settings-VDJK2BZ2.js");
       const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
       await removeWorktree(thread.repoPath, thread.worktreePath, {
         deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -6285,19 +6458,18 @@ var Orchestrator = class {
       throw new Error("Thread is not archived");
     }
     if (isGlobalThread(thread)) {
-      const { globalAgentCwd } = await import("../paths-TZX4L5X7.js");
+      const { globalAgentCwd } = await import("../paths-QCI3MTO5.js");
       updateThread(thread.id, { worktreePath: globalAgentCwd() });
       const restored2 = setStatus(thread.id, "idle");
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!existsSync14(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-EO5QAGJU.js");
-      const { execa: execa5 } = await import("execa");
+    if (!existsSync15(thread.worktreePath)) {
+      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-NKWN5ZTS.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
-      await execa5("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;
@@ -6844,6 +7016,15 @@ function mcpArchiveBlockedReason(thread) {
   return null;
 }
 
+// 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
 import { z } from "zod";
 
@@ -7471,7 +7652,7 @@ async function startMcpServer() {
     );
   }
   try {
-    const { maxConcurrentAgents } = await import("../app-settings-ZXPAB3QN.js");
+    const { maxConcurrentAgents } = await import("../app-settings-VDJK2BZ2.js");
     orch.setMaxConcurrent(maxConcurrentAgents());
   } catch {
   }
@@ -7514,7 +7695,9 @@ async function startMcpServer() {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
         const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : basename4(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)" }]
@@ -7523,13 +7706,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: z3.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,
@@ -7544,7 +7728,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) }] };
     }
@@ -7680,8 +7867,8 @@ async function startMcpServer() {
   registerSlackTools(server);
   registerLinearTools(server);
   if (sideboardMcpProfile() !== "worktree") {
-    const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-U3QJBV67.js");
-    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults } = await import("../app-settings-ZXPAB3QN.js");
+    const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-NBRUWYXO.js");
+    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults } = await import("../app-settings-VDJK2BZ2.js");
     const accountDefaults = resolveThreadDefaults();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
@@ -7870,13 +8057,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. Returns status, text, and lastError. If status is error, lastError/text is the failure \u2014 switch agent, tell the user, or retry; do not treat empty text as success.",
+      "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: z3.string(),
         timeoutMs: z3.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: [
@@ -7886,7 +8075,11 @@ async function startMcpServer() {
                 id: thread.id,
                 status: result.status,
                 text: result.text,
-                lastError: result.lastError
+                lastError: result.lastError,
+                stillRunning: result.stillRunning,
+                progress: result.progress,
+                lastActivityAt: result.lastActivityAt,
+                hint: result.stillRunning ? MCP_WAIT_STILL_RUNNING_HINT : void 0
               })
             }
           ]
@@ -7895,11 +8088,21 @@ async function startMcpServer() {
     );
     server.tool(
       "get_turn_result",
-      "Final assistant message (and lastError when the turn failed). Not the full transcript.",
+      "Assistant message when the turn finished, or live progress while stillRunning. Not the full transcript.",
       { ref: z3.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(
@@ -8016,7 +8219,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: z3.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
@@ -8044,7 +8247,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: z3.string().describe("Worktree thread id/ref"),
         action: z3.enum(AGENT_GIT_ACTIONS).describe(
@@ -8095,7 +8298,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: z3.string().describe("Worktree thread id/ref to fork"),
         through_index: z3.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
@@ -8140,7 +8343,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: z3.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
         through_index: z3.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),