@sideboard-ai/core 0.1.99 → 0.1.103

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-UYQYK2RY.js";
+} from "./chunk-27MCESES.js";
 import {
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
@@ -65,7 +65,7 @@ import {
   threadRequestsBrightsyMcp,
   totalTokens,
   writeInjectedMcpConfig
-} from "./chunk-MBP3XG57.js";
+} from "./chunk-H6LP57EF.js";
 import {
   CLOUD_COORDINATOR_BUSY_REPLY,
   CLOUD_COORDINATOR_STOPPED_REPLY,
@@ -93,7 +93,7 @@ import {
   parseForceStopMessage,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-FO67IJTY.js";
+} from "./chunk-HHLZWO7U.js";
 import {
   COORDINATOR_TOOL_PLAYBOOK,
   SLACK_REPLY_FORMATTING,
@@ -102,7 +102,7 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-XUWDLRAE.js";
+} from "./chunk-ETMRBJKA.js";
 import {
   brightsyConfigPath,
   brightsyMcpServerName,
@@ -114,7 +114,7 @@ import {
   loadBrightsyConfig,
   saveBrightsyConfig,
   switchBrightsyAccount
-} from "./chunk-QSLE4VEM.js";
+} from "./chunk-2GO3YKBA.js";
 import {
   LEGACY_PLAN_FILE_REL,
   PLAN_FILE_NAME,
@@ -133,20 +133,21 @@ import {
   cursorSdkMessageToEvents,
   fallbackTurnFailDetail,
   formatTurnExitError,
-  humanizeAgentFailDetail,
   looksLikeAgentFailureMessage,
   looksLikeInvalidAgentSession,
   parseCursorRunnerLine,
   pushTurnStderr,
-  summarizeTurnStderr
-} from "./chunk-GXSYI7FH.js";
+  shouldRetryFailedAgentTurn,
+  summarizeTurnStderr,
+  turnFailChatText
+} from "./chunk-HUKCGRAT.js";
 import {
   caffeinateHoldPath,
   getCaffeinateHold,
   isThreadCaffeinated,
   releaseCaffeinateHoldForThread,
   setCaffeinateHold
-} from "./chunk-NZPGMNFC.js";
+} from "./chunk-DCOZABNT.js";
 import {
   FAMOUS_SOCCER_TEAMS,
   addPrStackLayer,
@@ -166,6 +167,7 @@ import {
   currentBranch,
   detectGhStack,
   detectLocalMergeConflicts,
+  enqueueByKey,
   ensureGhPreferOrigin,
   extractGhErrorDetail,
   fetchPrHead,
@@ -225,10 +227,11 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   warmGithubAgentAuth,
+  withRepoGitLock,
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-CIRXAYWS.js";
+} from "./chunk-DHAGMJIK.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -297,7 +300,7 @@ import {
   updateIntegrationsSettings,
   updateOpencodeSettings,
   writeSecureJson
-} from "./chunk-FT2SQOL4.js";
+} from "./chunk-XHZJJWLI.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-TLPJHLLM.js";
@@ -317,7 +320,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-3WA37BRI.js";
+} from "./chunk-KGSVLZV6.js";
 import {
   THINKING_EFFORTS,
   isThinkingEffort,
@@ -348,11 +351,12 @@ import {
   sideboardReposDir,
   sideboardWorkspacesDir,
   threadFilePath,
+  threadLivePath,
   threadLockPath,
   threadsDir,
   workspaceSettingsSourceLabel,
   worktreesRoot
-} from "./chunk-B4R2VB2A.js";
+} from "./chunk-QZQEXME2.js";
 import {
   conductorBundledBinDir,
   enrichPathWithNpmGlobalBin,
@@ -1385,9 +1389,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-RSQXRLT7.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-UR4E3CCG.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-AKEY4WSO.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-UWHSD65V.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -3266,11 +3270,11 @@ 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");
@@ -3290,8 +3294,8 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
   }
   return out;
 }
-function attachmentsFromBuffers(buffers) {
-  return buffers.map((item) => {
+function attachmentsFromBuffers(buffers2) {
+  return buffers2.map((item) => {
     const name = (item.name || "file").replace(/[/\\]/g, "_") || "file";
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
@@ -3880,7 +3884,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-3MWWWSMF.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-XZBAKBO2.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3931,8 +3935,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" });
@@ -4433,7 +4440,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-4ZY4QPWQ.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-TKJXPNV4.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -5199,7 +5206,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 
 // src/git/pr-merge-archive.ts
 function normalizePrState(state) {
@@ -5444,9 +5451,132 @@ async function cloneRepoIntoSideboard(opts) {
   return { repoPath, workspace };
 }
 
+// src/store/turn-live.ts
+import {
+  existsSync as existsSync13,
+  renameSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync10
+} 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 path2 = threadLivePath(threadId);
+  const tmp = `${path2}.${process.pid}.tmp`;
+  try {
+    writeFileSync4(tmp, JSON.stringify(progress), "utf8");
+    renameSync(tmp, path2);
+  } catch {
+    try {
+      unlinkSync2(tmp);
+    } catch {
+    }
+  }
+}
+function readTurnLive(threadId) {
+  const path2 = threadLivePath(threadId);
+  if (!existsSync13(path2)) return null;
+  try {
+    const raw = JSON.parse(readFileSync10(path2, "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 path2 = threadLivePath(threadId);
+  if (!existsSync13(path2)) return;
+  try {
+    unlinkSync2(path2);
+  } catch {
+  }
+}
+
 // src/review/request-review.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname3, join as join13 } from "path";
 
 // src/review/review-request-template.ts
@@ -5592,9 +5722,9 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!existsSync13(abs)) return null;
+  if (!existsSync14(abs)) return null;
   try {
-    const content = readFileSync10(abs, "utf8");
+    const content = readFileSync11(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
@@ -5602,9 +5732,9 @@ function readTextIfPresent(abs) {
 }
 function ensureAttachmentsGitignore(worktreePath) {
   const gitignoreAbs = join13(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if (existsSync13(gitignoreAbs)) return;
+  if (existsSync14(gitignoreAbs)) return;
   mkdirSync4(dirname3(gitignoreAbs), { recursive: true });
-  writeFileSync4(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  writeFileSync5(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = join13(worktreePath, REPO_REVIEW_PATH);
@@ -5639,7 +5769,7 @@ function resolveReviewGuidelines(worktreePath) {
   }
   ensureAttachmentsGitignore(worktreePath);
   mkdirSync4(dirname3(localAbs), { recursive: true });
-  writeFileSync4(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  writeFileSync5(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -5661,7 +5791,7 @@ function ensureReviewRequestFile(worktreePath) {
   const localAbs = join13(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent(join13(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
-    const path2 = existsSync13(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
+    const path2 = existsSync14(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
     return {
       path: path2,
       name: REVIEW_REQUEST_NAME,
@@ -5670,7 +5800,7 @@ function ensureReviewRequestFile(worktreePath) {
     };
   }
   mkdirSync4(dirname3(repoAbs), { recursive: true });
-  writeFileSync4(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  writeFileSync5(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REPO_REVIEW_PATH,
     name: REPO_REVIEW_NAME,
@@ -5863,6 +5993,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;
@@ -5940,7 +6079,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;
@@ -5959,7 +6098,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled: autoCleanupOrphansEnabled2 } = await import("./app-settings-BRF7VKTQ.js");
+      const { autoCleanupOrphansEnabled: autoCleanupOrphansEnabled2 } = await import("./app-settings-EKJM2344.js");
       if (autoCleanupOrphansEnabled2() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -6127,7 +6266,7 @@ var Orchestrator = class {
       }
     }
     await setup;
-    const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await import("./app-settings-BRF7VKTQ.js");
+    const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await import("./app-settings-EKJM2344.js");
     if (autoRunAfterSetupEnabled2()) {
       try {
         await this.startDev(threadId);
@@ -6261,14 +6400,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) {
@@ -6297,7 +6432,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];
@@ -6405,7 +6551,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled: autoRenameBranchEnabled2, getGithubGitAuthMode: getGithubGitAuthMode2 } = await import("./app-settings-BRF7VKTQ.js");
+    const { autoRenameBranchEnabled: autoRenameBranchEnabled2, getGithubGitAuthMode: getGithubGitAuthMode2 } = await import("./app-settings-EKJM2344.js");
     const gitAuthMode = getGithubGitAuthMode2();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -6454,6 +6600,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 });
           }
@@ -6500,7 +6647,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-G34BYKL2.js");
+          const { recoverFinishedCursorRun } = await import("./cursor-recover-ZUJG6XRQ.js");
           for (let i = 0; i < 8; i++) {
             const recovered = recoverFinishedCursorRun({
               agentId: sessionId,
@@ -6517,19 +6664,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);
@@ -6578,10 +6722,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",
@@ -6664,6 +6805,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 {
@@ -6937,51 +7079,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);
     });
@@ -6989,10 +7136,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) {
@@ -7155,7 +7310,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled: autoArchiveOnMergeEnabled2 } = await import("./app-settings-BRF7VKTQ.js");
+    const { autoArchiveOnMergeEnabled: autoArchiveOnMergeEnabled2 } = await import("./app-settings-EKJM2344.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -7418,7 +7573,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);
@@ -7446,7 +7613,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-4ZY4QPWQ.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-TKJXPNV4.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -7454,6 +7621,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);
@@ -7468,7 +7639,7 @@ var Orchestrator = class {
         await runArchiveScript(thread.repoPath, thread.worktreePath);
       } catch {
       }
-      const { deleteBranchOnPurgeEnabled: deleteBranchOnPurgeEnabled2 } = await import("./app-settings-BRF7VKTQ.js");
+      const { deleteBranchOnPurgeEnabled: deleteBranchOnPurgeEnabled2 } = await import("./app-settings-EKJM2344.js");
       const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled2();
       await removeWorktree(thread.repoPath, thread.worktreePath, {
         deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -7482,19 +7653,18 @@ var Orchestrator = class {
       throw new Error("Thread is not archived");
     }
     if (isGlobalThread(thread)) {
-      const { globalAgentCwd: globalAgentCwd2 } = await import("./paths-JQM2XRAD.js");
+      const { globalAgentCwd: globalAgentCwd2 } = await import("./paths-UMEDHOS5.js");
       updateThread(thread.id, { worktreePath: globalAgentCwd2() });
       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-DA4BOV7G.js");
-      const { execa: execa5 } = await import("execa");
+    if (!existsSync15(thread.worktreePath)) {
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-PEUPFAKL.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;
@@ -7598,7 +7768,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-DA4BOV7G.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-PEUPFAKL.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({
@@ -7608,7 +7778,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-XAKWCV2E.js");
+  const { updateThread: upd } = await import("./thread-store-4OUEQ2DB.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -7731,6 +7901,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";
 
@@ -8358,7 +8537,7 @@ async function startMcpServer() {
     );
   }
   try {
-    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-BRF7VKTQ.js");
+    const { maxConcurrentAgents: maxConcurrentAgents2 } = await import("./app-settings-EKJM2344.js");
     orch.setMaxConcurrent(maxConcurrentAgents2());
   } catch {
   }
@@ -8401,7 +8580,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)" }]
@@ -8410,13 +8591,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,
@@ -8431,7 +8613,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) }] };
     }
@@ -8567,8 +8752,8 @@ async function startMcpServer() {
   registerSlackTools(server);
   registerLinearTools(server);
   if (sideboardMcpProfile() !== "worktree") {
-    const { getCaffeinateHold: getCaffeinateHold2, setCaffeinateHold: setCaffeinateHold2 } = await import("./caffeinate-hold-I7SG6UQR.js");
-    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-BRF7VKTQ.js");
+    const { getCaffeinateHold: getCaffeinateHold2, setCaffeinateHold: setCaffeinateHold2 } = await import("./caffeinate-hold-X3JNPR42.js");
+    const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await import("./app-settings-EKJM2344.js");
     const accountDefaults = resolveThreadDefaults2();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
@@ -8757,13 +8942,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: 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: [
@@ -8772,7 +8959,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
               })
             }
           ]
@@ -8781,11 +8973,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: 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(
@@ -8902,7 +9104,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 {
@@ -8930,7 +9132,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(
@@ -8981,7 +9183,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)"),
@@ -9026,7 +9228,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)"),
@@ -9693,7 +9895,7 @@ async function runCloudConnect(opts) {
 }
 
 // src/agents/user-mcp-config.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname4, join as join14 } from "path";
 function userCursorMcpConfigPath() {
@@ -9727,16 +9929,16 @@ function mergeSideboardIntoMcpServersJson(existing, sideboard) {
 }
 function writeMergedMcpServersJson(configPath, sideboard) {
   let existing = {};
-  if (existsSync15(configPath)) {
+  if (existsSync16(configPath)) {
     try {
-      existing = JSON.parse(readFileSync11(configPath, "utf8"));
+      existing = JSON.parse(readFileSync12(configPath, "utf8"));
     } catch {
       existing = {};
     }
   }
   const next = mergeSideboardIntoMcpServersJson(existing, sideboard);
   mkdirSync5(dirname4(configPath), { recursive: true });
-  writeFileSync5(configPath, `${JSON.stringify(next, null, 2)}
+  writeFileSync6(configPath, `${JSON.stringify(next, null, 2)}
 `);
 }
 function launchFromResolved(server) {
@@ -9754,7 +9956,7 @@ async function registerPackagedUserMcpClients() {
   const cursor = userCursorMcpConfigPath();
   writeMergedMcpServersJson(cursor, launch);
   const claude = userClaudeMcpConfigPath();
-  if (existsSync15(claude)) {
+  if (existsSync16(claude)) {
     writeMergedMcpServersJson(claude, launch);
     return { cursor, claude };
   }
@@ -10252,6 +10454,8 @@ function connectSession(ws, opts, log) {
 
 // src/slack/relay-protocol.ts
 import { randomBytes as randomBytes3 } from "crypto";
+var SLACK_RELAY_PING_INTERVAL_MS = 2e4;
+var SLACK_RELAY_PONG_TIMEOUT_MS = 15e3;
 function slackRelaySessionKey(teamId, userId, deviceId) {
   return `${teamId.trim()}:${userId.trim()}:${deviceId.trim()}`;
 }
@@ -10437,10 +10641,21 @@ function connectSession2(ws, opts, log) {
     const allowedUsers = new Set(
       opts.workspaces.map((w) => `${w.teamId.trim()}:${w.userId.trim()}`)
     );
+    const pingMs = opts.pingIntervalMs ?? SLACK_RELAY_PING_INTERVAL_MS;
+    const pongMs = opts.pongTimeoutMs ?? SLACK_RELAY_PONG_TIMEOUT_MS;
+    let pingTimer = null;
+    let pongTimer = null;
+    const stopKeepalive = () => {
+      if (pingTimer) clearInterval(pingTimer);
+      if (pongTimer) clearTimeout(pongTimer);
+      pingTimer = null;
+      pongTimer = null;
+    };
     const finish = (err) => {
       if (settled) return;
       settled = true;
       pending.clear();
+      stopKeepalive();
       opts.signal?.removeEventListener("abort", onAbort);
       if (err) reject(err);
       else resolve();
@@ -10453,6 +10668,25 @@ function connectSession2(ws, opts, log) {
       finish();
     };
     opts.signal?.addEventListener("abort", onAbort, { once: true });
+    const armPongTimeout = () => {
+      if (pongTimer) clearTimeout(pongTimer);
+      pongTimer = setTimeout(() => {
+        log("relay error: ping timeout");
+        try {
+          ws.close();
+        } catch {
+        }
+        finish(new Error("relay ping timeout"));
+      }, pongMs);
+    };
+    const pingOnce = () => {
+      try {
+        send(ws, { type: "ping" });
+        armPongTimeout();
+      } catch (err) {
+        finish(err instanceof Error ? err : new Error("relay ping failed"));
+      }
+    };
     ws.addEventListener("open", () => {
       const label = opts.deviceLabel?.trim() || opts.deviceId.trim();
       log(`Relay connected \xB7 ${label}`);
@@ -10467,6 +10701,8 @@ function connectSession2(ws, opts, log) {
           userToken: wsInfo.userToken
         });
       }
+      pingOnce();
+      pingTimer = setInterval(pingOnce, pingMs);
     });
     ws.addEventListener("error", () => {
       finish(new Error("WebSocket error"));
@@ -10478,7 +10714,13 @@ function connectSession2(ws, opts, log) {
       const raw = typeof ev.data === "string" ? ev.data : String(ev.data ?? "");
       const msg = parseSlackRelayServerMessage(raw);
       if (!msg) return;
-      if (msg.type === "pong") return;
+      if (msg.type === "pong") {
+        if (pongTimer) {
+          clearTimeout(pongTimer);
+          pongTimer = null;
+        }
+        return;
+      }
       if (msg.type === "error") {
         log(`relay error: ${msg.message}`);
         return;
@@ -10601,6 +10843,13 @@ function slackReplyThreadTs(msg) {
   if (msg.kind === "mention") return msg.ts;
   return void 0;
 }
+var SLACK_PROGRESS_DELAY_MS = 2e4;
+var SLACK_PROGRESS_EDIT_MS = 15e3;
+function formatSlackWorkingText(summary) {
+  const line = (summary ?? "").trim();
+  if (!line || /^working/i.test(line)) return "Working\u2026";
+  return `Working\u2026 ${line}`;
+}
 var SLACK_SEEN_REACTION = "eyes";
 function writeTokenForTeam(teamId) {
   const workspaces = listSlackWorkspacesRaw();
@@ -10637,8 +10886,8 @@ async function ackSlackInboundSeen(msg, opts) {
     log(`react error: ${errMsg}${hint}`);
   }
 }
-async function postSlackText(target, text3, opts) {
-  const stub = {
+function replyStub(target) {
+  return {
     teamId: target.teamId,
     channelId: target.channelId,
     ts: target.threadTs ?? "",
@@ -10646,12 +10895,15 @@ async function postSlackText(target, text3, opts) {
     text: "",
     kind: "dm"
   };
+}
+async function postSlackText(target, text3, opts) {
   if (opts.postReply) {
-    await opts.postReply(stub, text3);
-    return;
+    const result = await opts.postReply(replyStub(target), text3);
+    const ts2 = result && typeof result === "object" && typeof result.ts === "string" ? result.ts.trim() : "";
+    return ts2 ? { ts: ts2 } : null;
   }
   const token = writeTokenForTeam(target.teamId);
-  await slackApi(
+  const json = await slackApi(
     token,
     "chat.postMessage",
     {
@@ -10661,18 +10913,163 @@ async function postSlackText(target, text3, opts) {
     },
     opts.fetchImpl
   );
+  const ts = json.ts?.trim();
+  return ts ? { ts } : null;
 }
-async function postSlackReply(msg, text3, opts) {
-  await postSlackText(
+async function updateSlackText(target, ts, text3, opts) {
+  if (opts.updateReply) {
+    await opts.updateReply(replyStub(target), ts, text3);
+    return;
+  }
+  const token = writeTokenForTeam(target.teamId);
+  await slackApi(
+    token,
+    "chat.update",
     {
-      teamId: msg.teamId,
-      channelId: msg.channelId,
-      threadTs: slackReplyThreadTs(msg)
+      channel: target.channelId,
+      ts,
+      text: text3
     },
-    signForThisMac(text3),
-    opts
+    opts.fetchImpl
+  );
+}
+async function deleteSlackText(target, ts, opts) {
+  if (opts.deleteReply) {
+    await opts.deleteReply(replyStub(target), ts);
+    return;
+  }
+  const token = writeTokenForTeam(target.teamId);
+  await slackApi(
+    token,
+    "chat.delete",
+    {
+      channel: target.channelId,
+      ts
+    },
+    opts.fetchImpl
   );
 }
+function replyTargetOf(msg) {
+  return {
+    teamId: msg.teamId,
+    channelId: msg.channelId,
+    threadTs: slackReplyThreadTs(msg)
+  };
+}
+async function postSlackReply(msg, text3, opts) {
+  await postSlackText(replyTargetOf(msg), signForThisMac(text3), opts);
+}
+function startSlackTurnProgress(msg, threadId, opts) {
+  const log = opts.onLog ?? (() => void 0);
+  const target = replyTargetOf(msg);
+  const delayMs = opts.progressDelayMs ?? SLACK_PROGRESS_DELAY_MS;
+  const editMs = opts.progressEditMs ?? SLACK_PROGRESS_EDIT_MS;
+  let stopped = false;
+  let postedTs = null;
+  let lastBody = null;
+  let chain = Promise.resolve();
+  let editTimer = null;
+  const run2 = (fn) => {
+    const next = chain.then(fn, fn);
+    chain = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  };
+  const stillLive = () => {
+    if (stopped || slackInboundSuperseded(opts)) return false;
+    const thread = readThread(threadId());
+    return Boolean(thread && (thread.status === "running" || thread.status === "queued"));
+  };
+  const postWorking = async () => {
+    if (!stillLive()) return;
+    const summary = readTurnLive(threadId())?.summary ?? "Working\u2026";
+    const body = formatSlackWorkingText(summary);
+    try {
+      const posted = await postSlackText(target, signForThisMac(body), opts);
+      postedTs = posted?.ts ?? postedTs;
+      lastBody = body;
+      if (postedTs && !stopped && !editTimer) {
+        editTimer = setInterval(() => {
+          void run2(editWorking);
+        }, editMs);
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log(`progress post error: ${errMsg}`);
+    }
+  };
+  const editWorking = async () => {
+    if (!postedTs || !stillLive()) return;
+    const summary = readTurnLive(threadId())?.summary ?? "Working\u2026";
+    const body = formatSlackWorkingText(summary);
+    if (body === lastBody) return;
+    lastBody = body;
+    try {
+      await updateSlackText(target, postedTs, signForThisMac(body), opts);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log(`progress update error: ${errMsg}`);
+    }
+  };
+  const delayTimer = setTimeout(() => {
+    void run2(postWorking);
+  }, delayMs);
+  const stop = () => {
+    stopped = true;
+    clearTimeout(delayTimer);
+    if (editTimer) {
+      clearInterval(editTimer);
+      editTimer = null;
+    }
+  };
+  return {
+    stop,
+    discard: () => {
+      stop();
+      return run2(async () => {
+        if (!postedTs) return;
+        const ts = postedTs;
+        postedTs = null;
+        try {
+          await deleteSlackText(target, ts, opts);
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log(`progress delete error: ${errMsg}`);
+        }
+      });
+    },
+    finishWith: (text3) => {
+      stop();
+      return run2(async () => {
+        const signed = signForThisMac(text3.trim());
+        if (!signed) {
+          if (!postedTs) return;
+          const ts = postedTs;
+          postedTs = null;
+          try {
+            await deleteSlackText(target, ts, opts);
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log(`progress delete error: ${errMsg}`);
+          }
+          return;
+        }
+        if (postedTs) {
+          try {
+            await updateSlackText(target, postedTs, signed, opts);
+            return;
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log(`progress update error: ${errMsg}`);
+          }
+        }
+        await postSlackText(target, signed, opts);
+      });
+    }
+  };
+}
 var lastRelayed = /* @__PURE__ */ new Map();
 function markRelayed(threadId, text3) {
   lastRelayed.set(threadId, `${threadId}:${text3}`);
@@ -10764,10 +11161,15 @@ async function handleSlackInbound(msg, opts) {
     });
   };
   bindReplyTarget(fresh.id);
+  const progress = startSlackTurnProgress(msg, () => fresh.id, opts);
   const runTurn = async (threadId) => {
     await orch.send(threadId, prompt);
     await orch.waitForTurn(threadId, 14 * 60 * 1e3);
   };
+  const dropProgress = async (reason) => {
+    log(reason);
+    await progress.discard();
+  };
   let reply;
   try {
     try {
@@ -10780,12 +11182,12 @@ async function handleSlackInbound(msg, opts) {
       await runTurn(fresh.id);
     }
     if (slackInboundSuperseded(opts)) {
-      log(`turn finished ${msg.ts} (superseded)`);
+      await dropProgress(`turn finished ${msg.ts} (superseded)`);
       return;
     }
     let after = readThread(fresh.id);
     if (after?.status === "stopped") {
-      log(`turn finished ${msg.ts} (interrupted, skip post)`);
+      await dropProgress(`turn finished ${msg.ts} (interrupted, skip post)`);
       return;
     }
     if (!after || after.status === "archived") {
@@ -10794,46 +11196,48 @@ async function handleSlackInbound(msg, opts) {
       bindReplyTarget(fresh.id);
       await runTurn(fresh.id);
       if (slackInboundSuperseded(opts)) {
-        log(`turn finished ${msg.ts} (superseded)`);
+        await dropProgress(`turn finished ${msg.ts} (superseded)`);
         return;
       }
       after = readThread(fresh.id);
       if (!after || after.status === "stopped" || after.status === "archived") {
-        log(`turn finished ${msg.ts} (interrupted, skip post)`);
+        await dropProgress(`turn finished ${msg.ts} (interrupted, skip post)`);
         return;
       }
     }
     reply = orch.getTurnResult(fresh.id).text.trim();
   } catch (err) {
     if (slackInboundSuperseded(opts)) {
-      log(`turn error ${msg.ts} (superseded)`);
+      await dropProgress(`turn error ${msg.ts} (superseded)`);
       return;
     }
     const errMsg = err instanceof Error ? err.message : String(err);
     if (slackCoordinatorGone(err)) {
-      log(`turn finished ${msg.ts} (thread gone, skip post)`);
+      await dropProgress(`turn finished ${msg.ts} (thread gone, skip post)`);
       return;
     }
     const timedOut = /timed out|timeout/i.test(errMsg);
     const errorReply = timedOut ? SLACK_LISTEN_TIMEOUT_REPLY : `Sideboard coordinator error: ${errMsg}`;
-    await postSlackReply(msg, errorReply, opts).catch((postErr) => {
+    try {
+      await progress.finishWith(errorReply);
+      log(`replied error ${msg.ts}: ${errMsg}`);
+    } catch (postErr) {
       const postMsg = postErr instanceof Error ? postErr.message : String(postErr);
       log(`post error: ${postMsg}`);
-    });
-    log(`replied error ${msg.ts}: ${errMsg}`);
+    }
     if (!timedOut) throw err;
     return;
   }
   if (!reply) {
-    log(`post error: no agent text to send for ${msg.ts}`);
+    await dropProgress(`post error: no agent text to send for ${msg.ts}`);
     return;
   }
   if (alreadyRelayed(fresh.id, reply)) {
-    log(`turn finished ${msg.ts} (already posted)`);
+    await dropProgress(`turn finished ${msg.ts} (already posted)`);
     return;
   }
   try {
-    await postSlackReply(msg, reply, opts);
+    await progress.finishWith(reply);
     markRelayed(fresh.id, reply);
     log(`replied ${msg.ts} (${reply.length} chars)`);
   } catch (err) {
@@ -11384,6 +11788,20 @@ async function startSlackRelayServer(opts) {
         }
       }
     };
+    const ping = setInterval(() => {
+      if (ws.readyState !== ws.OPEN) {
+        clearInterval(ping);
+        return;
+      }
+      try {
+        ws.ping();
+      } catch {
+        clearInterval(ping);
+      }
+    }, SLACK_RELAY_PING_INTERVAL_MS);
+    const stopPing = () => clearInterval(ping);
+    ws.on("close", stopPing);
+    ws.on("error", stopPing);
     log("desktop connected");
     ws.on("message", (data) => {
       const raw = typeof data === "string" ? data : data.toString("utf8");
@@ -11494,6 +11912,8 @@ export {
   SLACK_LISTEN_TIMEOUT_REPLY,
   SLACK_OAUTH_CANCELLED,
   SLACK_OAUTH_REDIRECT,
+  SLACK_PROGRESS_DELAY_MS,
+  SLACK_PROGRESS_EDIT_MS,
   SLACK_REPLY_FORMATTING,
   SLACK_SEEN_REACTION,
   SlackOAuthCancelledError,
@@ -11651,6 +12071,7 @@ export {
   formatSlackInboundPrompt,
   formatSlackRepliesForTurn,
   formatSlackSignedReply,
+  formatSlackWorkingText,
   formatTranscriptMarkdown,
   formatUiReminder,
   formatWorkspaceInventory,
@@ -11946,6 +12367,7 @@ export {
   thisProcessShouldDrainAgentQueues,
   threadDisplayLabel,
   threadFilePath,
+  threadLivePath,
   threadLockPath,
   threadRequestsBrightsyMcp,
   threadsDir,
@@ -11969,6 +12391,7 @@ export {
   userClaudeMcpConfigPath,
   userCursorMcpConfigPath,
   validateLinearApiKey,
+  waitForPidExit,
   warmGithubAgentAuth,
   withAgentInstructions,
   withExportedPath,