@sideboard-ai/core 0.1.95 → 0.1.97

package/dist/index.cjs

@@ -11694,23 +11694,24 @@ async function countUnpushedCommits(worktreePath) {
     reject: false
   });
   const branch = head.stdout.trim();
+  if (branch && branch !== "HEAD") {
+    const remote = await git(
+      ["rev-list", "--count", `origin/${branch}..HEAD`],
+      worktreePath,
+      { reject: false }
+    );
+    if (remote.exitCode === 0) {
+      const n2 = Number(remote.stdout.trim());
+      return Number.isFinite(n2) ? n2 : 0;
+    }
+  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
     { reject: false }
   );
-  if (upstream.exitCode === 0) {
-    const n2 = Number(upstream.stdout.trim());
-    return Number.isFinite(n2) ? n2 : 0;
-  }
-  if (!branch || branch === "HEAD") return 0;
-  const remote = await git(
-    ["rev-list", "--count", `origin/${branch}..HEAD`],
-    worktreePath,
-    { reject: false }
-  );
-  if (remote.exitCode !== 0) return 0;
-  const n = Number(remote.stdout.trim());
+  if (upstream.exitCode !== 0) return 0;
+  const n = Number(upstream.stdout.trim());
   return Number.isFinite(n) ? n : 0;
 }
 function splitCombinedDiff(stdout) {
@@ -15418,6 +15419,11 @@ function isPidAlive(pid) {
     return false;
   }
 }
+function writeLiveStatus(threadId, status, lastError) {
+  const latest = readThread(threadId);
+  if (!latest || latest.status === "archived") return latest;
+  return setStatus(threadId, status, lastError);
+}
 var Orchestrator = class {
   events = new import_node_events.EventEmitter();
   processes = /* @__PURE__ */ new Map();
@@ -15723,6 +15729,9 @@ var Orchestrator = class {
   }
   async send(threadRef, prompt) {
     const thread = this.requireThread(threadRef);
+    if (thread.status === "archived") {
+      throw new Error(`Thread is archived: ${thread.id}`);
+    }
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
       const queue = [...current.queue, prompt];
@@ -15816,7 +15825,7 @@ var Orchestrator = class {
           break;
         }
         const thread = readThread(threadId);
-        if (!thread || thread.queue.length === 0) {
+        if (!thread || thread.status === "archived" || thread.queue.length === 0) {
           if (thread && thread.status === "queued") {
             setStatus(threadId, "idle");
             this.emit({ type: "status_changed", threadId, status: "idle" });
@@ -15847,14 +15856,17 @@ var Orchestrator = class {
     }
   }
   async runTurn(threadId, prompt) {
-    let thread = this.requireThread(threadId);
+    const existing = readThread(threadId);
+    if (!existing || existing.status === "archived") return;
+    let thread = existing;
     if (isGlobalThread(thread) && thread.sessionId && orchestratorSessionPoisonedByBuiltins(thread)) {
       thread = updateThread(threadId, { sessionId: null });
     }
+    const running = writeLiveStatus(threadId, "running");
+    if (!running || running.status !== "running") return;
     this.runningCount += 1;
     const turnStartedAt = Date.now();
     this.startingTurns.add(threadId);
-    setStatus(threadId, "running");
     this.emit({ type: "status_changed", threadId, status: "running" });
     this.emit({ type: "turn_started", threadId, prompt });
     try {
@@ -16125,8 +16137,8 @@ var Orchestrator = class {
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
-      const afterTurn = this.requireThread(threadId);
-      if (afterTurn.planMode && afterTurn.worktreePath?.trim()) {
+      const afterTurn = readThread(threadId);
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.worktreePath?.trim()) {
         const presented = extractPresentedPlan(parts);
         const exited = parts.some(
           (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
@@ -16139,29 +16151,34 @@ var Orchestrator = class {
           }
         }
       }
-      if (afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
         (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
       )) {
         updateThread(threadId, { sessionId: null });
       }
       await syncThreadBranchFromGit(threadId);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
       } else {
         const failDetail = formatTurnExitError(exitCode, detail);
         const explainedInChat = exitCode !== 0 && Boolean(chatText) && (looksLikeAgentFailureMessage(chatText) || failDetail && chatText.includes(failDetail.replace(/^exit\s*\d+:\s*/i, "").trim()));
-        setStatus(
+        const nextStatus = exitCode === 0 ? "idle" : "error";
+        const written = writeLiveStatus(
           threadId,
-          exitCode === 0 ? "idle" : "error",
+          nextStatus,
           exitCode === 0 || explainedInChat ? null : failDetail
         );
-        this.emit({
-          type: "status_changed",
-          threadId,
-          status: exitCode === 0 ? "idle" : "error"
-        });
+        if (written && written.status !== "archived") {
+          this.emit({
+            type: "status_changed",
+            threadId,
+            status: written.status
+          });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
         if (exitCode !== 0) {
           const blob = [chatText, detail].filter(Boolean).join("\n");
@@ -16172,13 +16189,17 @@ var Orchestrator = class {
       const message = err instanceof Error ? err.message : String(err);
       await syncThreadBranchFromGit(threadId).catch(() => void 0);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
       } else {
-        setStatus(threadId, "error", message);
-        this.emit({ type: "error", threadId, message });
-        this.emit({ type: "status_changed", threadId, status: "error" });
+        const written = writeLiveStatus(threadId, "error", message);
+        if (written?.status === "error") {
+          this.emit({ type: "error", threadId, message });
+          this.emit({ type: "status_changed", threadId, status: "error" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
         void this.maybeHandleOrchestrationQuotaFailover(threadId, message);
       }
@@ -16225,9 +16246,11 @@ var Orchestrator = class {
     if (handle) handle.kill();
     const proc = this.processes.get(`${thread.id}:agent`);
     if (proc) proc.kill();
-    setStatus(thread.id, "stopped");
-    this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
-    return this.requireThread(thread.id);
+    const stopped = writeLiveStatus(thread.id, "stopped") ?? readThread(thread.id) ?? thread;
+    if (stopped.status === "stopped") {
+      this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+    }
+    return stopped;
   }
   async startDev(threadRef, scriptName) {
     const thread = this.requireThread(threadRef);
@@ -16463,11 +16486,21 @@ var Orchestrator = class {
       const off = this.on((event) => {
         if (event.type === "turn_finished" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
         if (event.type === "error" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
       });
       const timer = setInterval(() => {
@@ -16477,7 +16510,13 @@ var Orchestrator = class {
           reject(new Error("wait_for_turn timed out"));
         }
         const current = readThread(thread.id);
-        if (current && !["running", "queued"].includes(current.status)) {
+        if (!current) {
+          clearInterval(timer);
+          off();
+          reject(new Error(`Thread not found: ${thread.id}`));
+          return;
+        }
+        if (!["running", "queued"].includes(current.status)) {
           clearInterval(timer);
           off();
           resolve(current);
@@ -20094,10 +20133,10 @@ function slackInboundSuperseded(opts) {
 function interruptSlackCoordinatorForInbound(msg, agent, log = () => void 0) {
   const userId = msg.userId?.trim();
   if (!userId) return false;
-  const coordinator = ensureSlackCoordinator(msg.teamId, userId, agent);
-  const fresh = readThread(coordinator.id) ?? coordinator;
-  if (fresh.status !== "running" && fresh.status !== "queued") return false;
   try {
+    const coordinator = ensureSlackCoordinator(msg.teamId, userId, agent);
+    const fresh = readThread(coordinator.id) ?? coordinator;
+    if (fresh.status !== "running" && fresh.status !== "queued") return false;
     getOrchestrator().stop(fresh.id, { clearQueue: true });
     log(
       `interrupt ${msg.kind} ${msg.ts} \u2192 coordinator ${fresh.id.slice(0, 8)} (${fresh.status})`
@@ -20137,7 +20176,7 @@ function slackReplyThreadTs(msg) {
   if (msg.kind === "mention") return msg.ts;
   return void 0;
 }
-var SLACK_SEEN_REACTION = "+1";
+var SLACK_SEEN_REACTION = "eyes";
 function writeTokenForTeam(teamId) {
   const workspaces = listSlackWorkspacesRaw();
   const ws = workspaces.find((w) => w.team_id === teamId);
@@ -20303,7 +20342,7 @@ async function handleSlackInbound(msg, opts) {
       return;
     }
     const after = readThread(fresh.id);
-    if (after?.status === "stopped") {
+    if (!after || after.status === "stopped" || after.status === "archived") {
       log(`turn finished ${msg.ts} (interrupted, skip post)`);
       return;
     }
@@ -20314,6 +20353,11 @@ async function handleSlackInbound(msg, opts) {
       return;
     }
     const errMsg = err instanceof Error ? err.message : String(err);
+    const gone = /thread not found/i.test(errMsg);
+    if (gone) {
+      log(`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) => {

package/dist/index.d.cts

@@ -4262,7 +4262,7 @@ interface SlackListenOptions {
      */
     inboundGeneration?: number;
     currentInboundGeneration?: () => number;
-    /** Listen already acked; skip the thumbs-up in handleSlackInbound. */
+    /** Listen already acked; skip the eyes reaction in handleSlackInbound. */
     skipAck?: boolean;
 }
 /**
@@ -4276,9 +4276,9 @@ declare function formatSlackInboundPrompt(msg: SlackInboundMessage): string;
  * more than one device can see who answered and address follow-ups the same way.
  */
 declare function formatSlackSignedReply(deviceLabel: string, text: string): string;
-/** Slack emoji short name for “seen / got it”. */
-declare const SLACK_SEEN_REACTION = "+1";
-/** Thumbs-up the inbound message so Slack shows the bot saw it. */
+/** Slack emoji short name for “seen / looking at this”. */
+declare const SLACK_SEEN_REACTION = "eyes";
+/** Eyes-react the inbound message so Slack shows the bot saw it. */
 declare function ackSlackInboundSeen(msg: SlackInboundMessage, opts: Pick<SlackListenOptions, 'addReaction' | 'fetchImpl' | 'onLog'>): Promise<void>;
 declare function handleSlackInbound(msg: SlackInboundMessage, opts: SlackListenOptions): Promise<void>;
 /**

package/dist/index.d.ts

@@ -4262,7 +4262,7 @@ interface SlackListenOptions {
      */
     inboundGeneration?: number;
     currentInboundGeneration?: () => number;
-    /** Listen already acked; skip the thumbs-up in handleSlackInbound. */
+    /** Listen already acked; skip the eyes reaction in handleSlackInbound. */
     skipAck?: boolean;
 }
 /**
@@ -4276,9 +4276,9 @@ declare function formatSlackInboundPrompt(msg: SlackInboundMessage): string;
  * more than one device can see who answered and address follow-ups the same way.
  */
 declare function formatSlackSignedReply(deviceLabel: string, text: string): string;
-/** Slack emoji short name for “seen / got it”. */
-declare const SLACK_SEEN_REACTION = "+1";
-/** Thumbs-up the inbound message so Slack shows the bot saw it. */
+/** Slack emoji short name for “seen / looking at this”. */
+declare const SLACK_SEEN_REACTION = "eyes";
+/** Eyes-react the inbound message so Slack shows the bot saw it. */
 declare function ackSlackInboundSeen(msg: SlackInboundMessage, opts: Pick<SlackListenOptions, 'addReaction' | 'fetchImpl' | 'onLog'>): Promise<void>;
 declare function handleSlackInbound(msg: SlackInboundMessage, opts: SlackListenOptions): Promise<void>;
 /**

package/dist/index.js

@@ -2151,23 +2151,24 @@ async function countUnpushedCommits(worktreePath) {
     reject: false
   });
   const branch = head.stdout.trim();
+  if (branch && branch !== "HEAD") {
+    const remote = await git(
+      ["rev-list", "--count", `origin/${branch}..HEAD`],
+      worktreePath,
+      { reject: false }
+    );
+    if (remote.exitCode === 0) {
+      const n2 = Number(remote.stdout.trim());
+      return Number.isFinite(n2) ? n2 : 0;
+    }
+  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
     { reject: false }
   );
-  if (upstream.exitCode === 0) {
-    const n2 = Number(upstream.stdout.trim());
-    return Number.isFinite(n2) ? n2 : 0;
-  }
-  if (!branch || branch === "HEAD") return 0;
-  const remote = await git(
-    ["rev-list", "--count", `origin/${branch}..HEAD`],
-    worktreePath,
-    { reject: false }
-  );
-  if (remote.exitCode !== 0) return 0;
-  const n = Number(remote.stdout.trim());
+  if (upstream.exitCode !== 0) return 0;
+  const n = Number(upstream.stdout.trim());
   return Number.isFinite(n) ? n : 0;
 }
 function splitCombinedDiff(stdout) {
@@ -5810,6 +5811,11 @@ function isPidAlive(pid) {
     return false;
   }
 }
+function writeLiveStatus(threadId, status, lastError) {
+  const latest = readThread(threadId);
+  if (!latest || latest.status === "archived") return latest;
+  return setStatus(threadId, status, lastError);
+}
 var Orchestrator = class {
   events = new EventEmitter();
   processes = /* @__PURE__ */ new Map();
@@ -6115,6 +6121,9 @@ var Orchestrator = class {
   }
   async send(threadRef, prompt) {
     const thread = this.requireThread(threadRef);
+    if (thread.status === "archived") {
+      throw new Error(`Thread is archived: ${thread.id}`);
+    }
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
       const queue = [...current.queue, prompt];
@@ -6208,7 +6217,7 @@ var Orchestrator = class {
           break;
         }
         const thread = readThread(threadId);
-        if (!thread || thread.queue.length === 0) {
+        if (!thread || thread.status === "archived" || thread.queue.length === 0) {
           if (thread && thread.status === "queued") {
             setStatus(threadId, "idle");
             this.emit({ type: "status_changed", threadId, status: "idle" });
@@ -6239,14 +6248,17 @@ var Orchestrator = class {
     }
   }
   async runTurn(threadId, prompt) {
-    let thread = this.requireThread(threadId);
+    const existing = readThread(threadId);
+    if (!existing || existing.status === "archived") return;
+    let thread = existing;
     if (isGlobalThread(thread) && thread.sessionId && orchestratorSessionPoisonedByBuiltins(thread)) {
       thread = updateThread(threadId, { sessionId: null });
     }
+    const running = writeLiveStatus(threadId, "running");
+    if (!running || running.status !== "running") return;
     this.runningCount += 1;
     const turnStartedAt = Date.now();
     this.startingTurns.add(threadId);
-    setStatus(threadId, "running");
     this.emit({ type: "status_changed", threadId, status: "running" });
     this.emit({ type: "turn_started", threadId, prompt });
     try {
@@ -6517,8 +6529,8 @@ var Orchestrator = class {
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
-      const afterTurn = this.requireThread(threadId);
-      if (afterTurn.planMode && afterTurn.worktreePath?.trim()) {
+      const afterTurn = readThread(threadId);
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.worktreePath?.trim()) {
         const presented = extractPresentedPlan(parts);
         const exited = parts.some(
           (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
@@ -6531,29 +6543,34 @@ var Orchestrator = class {
           }
         }
       }
-      if (afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
         (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
       )) {
         updateThread(threadId, { sessionId: null });
       }
       await syncThreadBranchFromGit(threadId);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
       } else {
         const failDetail = formatTurnExitError(exitCode, detail);
         const explainedInChat = exitCode !== 0 && Boolean(chatText) && (looksLikeAgentFailureMessage(chatText) || failDetail && chatText.includes(failDetail.replace(/^exit\s*\d+:\s*/i, "").trim()));
-        setStatus(
+        const nextStatus = exitCode === 0 ? "idle" : "error";
+        const written = writeLiveStatus(
           threadId,
-          exitCode === 0 ? "idle" : "error",
+          nextStatus,
           exitCode === 0 || explainedInChat ? null : failDetail
         );
-        this.emit({
-          type: "status_changed",
-          threadId,
-          status: exitCode === 0 ? "idle" : "error"
-        });
+        if (written && written.status !== "archived") {
+          this.emit({
+            type: "status_changed",
+            threadId,
+            status: written.status
+          });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
         if (exitCode !== 0) {
           const blob = [chatText, detail].filter(Boolean).join("\n");
@@ -6564,13 +6581,17 @@ var Orchestrator = class {
       const message = err instanceof Error ? err.message : String(err);
       await syncThreadBranchFromGit(threadId).catch(() => void 0);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
       } else {
-        setStatus(threadId, "error", message);
-        this.emit({ type: "error", threadId, message });
-        this.emit({ type: "status_changed", threadId, status: "error" });
+        const written = writeLiveStatus(threadId, "error", message);
+        if (written?.status === "error") {
+          this.emit({ type: "error", threadId, message });
+          this.emit({ type: "status_changed", threadId, status: "error" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
         void this.maybeHandleOrchestrationQuotaFailover(threadId, message);
       }
@@ -6617,9 +6638,11 @@ var Orchestrator = class {
     if (handle) handle.kill();
     const proc = this.processes.get(`${thread.id}:agent`);
     if (proc) proc.kill();
-    setStatus(thread.id, "stopped");
-    this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
-    return this.requireThread(thread.id);
+    const stopped = writeLiveStatus(thread.id, "stopped") ?? readThread(thread.id) ?? thread;
+    if (stopped.status === "stopped") {
+      this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+    }
+    return stopped;
   }
   async startDev(threadRef, scriptName) {
     const thread = this.requireThread(threadRef);
@@ -6855,11 +6878,21 @@ var Orchestrator = class {
       const off = this.on((event) => {
         if (event.type === "turn_finished" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
         if (event.type === "error" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
       });
       const timer = setInterval(() => {
@@ -6869,7 +6902,13 @@ var Orchestrator = class {
           reject(new Error("wait_for_turn timed out"));
         }
         const current = readThread(thread.id);
-        if (current && !["running", "queued"].includes(current.status)) {
+        if (!current) {
+          clearInterval(timer);
+          off();
+          reject(new Error(`Thread not found: ${thread.id}`));
+          return;
+        }
+        if (!["running", "queued"].includes(current.status)) {
           clearInterval(timer);
           off();
           resolve(current);
@@ -10444,10 +10483,10 @@ function slackInboundSuperseded(opts) {
 function interruptSlackCoordinatorForInbound(msg, agent, log = () => void 0) {
   const userId = msg.userId?.trim();
   if (!userId) return false;
-  const coordinator = ensureSlackCoordinator(msg.teamId, userId, agent);
-  const fresh = readThread(coordinator.id) ?? coordinator;
-  if (fresh.status !== "running" && fresh.status !== "queued") return false;
   try {
+    const coordinator = ensureSlackCoordinator(msg.teamId, userId, agent);
+    const fresh = readThread(coordinator.id) ?? coordinator;
+    if (fresh.status !== "running" && fresh.status !== "queued") return false;
     getOrchestrator().stop(fresh.id, { clearQueue: true });
     log(
       `interrupt ${msg.kind} ${msg.ts} \u2192 coordinator ${fresh.id.slice(0, 8)} (${fresh.status})`
@@ -10487,7 +10526,7 @@ function slackReplyThreadTs(msg) {
   if (msg.kind === "mention") return msg.ts;
   return void 0;
 }
-var SLACK_SEEN_REACTION = "+1";
+var SLACK_SEEN_REACTION = "eyes";
 function writeTokenForTeam(teamId) {
   const workspaces = listSlackWorkspacesRaw();
   const ws = workspaces.find((w) => w.team_id === teamId);
@@ -10653,7 +10692,7 @@ async function handleSlackInbound(msg, opts) {
       return;
     }
     const after = readThread(fresh.id);
-    if (after?.status === "stopped") {
+    if (!after || after.status === "stopped" || after.status === "archived") {
       log(`turn finished ${msg.ts} (interrupted, skip post)`);
       return;
     }
@@ -10664,6 +10703,11 @@ async function handleSlackInbound(msg, opts) {
       return;
     }
     const errMsg = err instanceof Error ? err.message : String(err);
+    const gone = /thread not found/i.test(errMsg);
+    if (gone) {
+      log(`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) => {

package/dist/mcp/run-stdio.cjs

@@ -12124,23 +12124,24 @@ async function countUnpushedCommits(worktreePath) {
     reject: false
   });
   const branch = head.stdout.trim();
+  if (branch && branch !== "HEAD") {
+    const remote = await git(
+      ["rev-list", "--count", `origin/${branch}..HEAD`],
+      worktreePath,
+      { reject: false }
+    );
+    if (remote.exitCode === 0) {
+      const n2 = Number(remote.stdout.trim());
+      return Number.isFinite(n2) ? n2 : 0;
+    }
+  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
     { reject: false }
   );
-  if (upstream.exitCode === 0) {
-    const n2 = Number(upstream.stdout.trim());
-    return Number.isFinite(n2) ? n2 : 0;
-  }
-  if (!branch || branch === "HEAD") return 0;
-  const remote = await git(
-    ["rev-list", "--count", `origin/${branch}..HEAD`],
-    worktreePath,
-    { reject: false }
-  );
-  if (remote.exitCode !== 0) return 0;
-  const n = Number(remote.stdout.trim());
+  if (upstream.exitCode !== 0) return 0;
+  const n = Number(upstream.stdout.trim());
   return Number.isFinite(n) ? n : 0;
 }
 function splitCombinedDiff(stdout) {
@@ -13466,6 +13467,11 @@ function isPidAlive(pid) {
     return false;
   }
 }
+function writeLiveStatus(threadId, status, lastError) {
+  const latest = readThread(threadId);
+  if (!latest || latest.status === "archived") return latest;
+  return setStatus(threadId, status, lastError);
+}
 var Orchestrator = class {
   events = new import_node_events.EventEmitter();
   processes = /* @__PURE__ */ new Map();
@@ -13771,6 +13777,9 @@ var Orchestrator = class {
   }
   async send(threadRef, prompt) {
     const thread = this.requireThread(threadRef);
+    if (thread.status === "archived") {
+      throw new Error(`Thread is archived: ${thread.id}`);
+    }
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
       const queue = [...current.queue, prompt];
@@ -13864,7 +13873,7 @@ var Orchestrator = class {
           break;
         }
         const thread = readThread(threadId);
-        if (!thread || thread.queue.length === 0) {
+        if (!thread || thread.status === "archived" || thread.queue.length === 0) {
           if (thread && thread.status === "queued") {
             setStatus(threadId, "idle");
             this.emit({ type: "status_changed", threadId, status: "idle" });
@@ -13895,14 +13904,17 @@ var Orchestrator = class {
     }
   }
   async runTurn(threadId, prompt) {
-    let thread = this.requireThread(threadId);
+    const existing = readThread(threadId);
+    if (!existing || existing.status === "archived") return;
+    let thread = existing;
     if (isGlobalThread(thread) && thread.sessionId && orchestratorSessionPoisonedByBuiltins(thread)) {
       thread = updateThread(threadId, { sessionId: null });
     }
+    const running = writeLiveStatus(threadId, "running");
+    if (!running || running.status !== "running") return;
     this.runningCount += 1;
     const turnStartedAt = Date.now();
     this.startingTurns.add(threadId);
-    setStatus(threadId, "running");
     this.emit({ type: "status_changed", threadId, status: "running" });
     this.emit({ type: "turn_started", threadId, prompt });
     try {
@@ -14173,8 +14185,8 @@ var Orchestrator = class {
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
-      const afterTurn = this.requireThread(threadId);
-      if (afterTurn.planMode && afterTurn.worktreePath?.trim()) {
+      const afterTurn = readThread(threadId);
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.worktreePath?.trim()) {
         const presented = extractPresentedPlan(parts);
         const exited = parts.some(
           (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
@@ -14187,29 +14199,34 @@ var Orchestrator = class {
           }
         }
       }
-      if (afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
         (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
       )) {
         updateThread(threadId, { sessionId: null });
       }
       await syncThreadBranchFromGit(threadId);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
       } else {
         const failDetail = formatTurnExitError(exitCode, detail);
         const explainedInChat = exitCode !== 0 && Boolean(chatText) && (looksLikeAgentFailureMessage(chatText) || failDetail && chatText.includes(failDetail.replace(/^exit\s*\d+:\s*/i, "").trim()));
-        setStatus(
+        const nextStatus = exitCode === 0 ? "idle" : "error";
+        const written = writeLiveStatus(
           threadId,
-          exitCode === 0 ? "idle" : "error",
+          nextStatus,
           exitCode === 0 || explainedInChat ? null : failDetail
         );
-        this.emit({
-          type: "status_changed",
-          threadId,
-          status: exitCode === 0 ? "idle" : "error"
-        });
+        if (written && written.status !== "archived") {
+          this.emit({
+            type: "status_changed",
+            threadId,
+            status: written.status
+          });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
         if (exitCode !== 0) {
           const blob = [chatText, detail].filter(Boolean).join("\n");
@@ -14220,13 +14237,17 @@ var Orchestrator = class {
       const message = err instanceof Error ? err.message : String(err);
       await syncThreadBranchFromGit(threadId).catch(() => void 0);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
       } else {
-        setStatus(threadId, "error", message);
-        this.emit({ type: "error", threadId, message });
-        this.emit({ type: "status_changed", threadId, status: "error" });
+        const written = writeLiveStatus(threadId, "error", message);
+        if (written?.status === "error") {
+          this.emit({ type: "error", threadId, message });
+          this.emit({ type: "status_changed", threadId, status: "error" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
         void this.maybeHandleOrchestrationQuotaFailover(threadId, message);
       }
@@ -14273,9 +14294,11 @@ var Orchestrator = class {
     if (handle) handle.kill();
     const proc = this.processes.get(`${thread.id}:agent`);
     if (proc) proc.kill();
-    setStatus(thread.id, "stopped");
-    this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
-    return this.requireThread(thread.id);
+    const stopped = writeLiveStatus(thread.id, "stopped") ?? readThread(thread.id) ?? thread;
+    if (stopped.status === "stopped") {
+      this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+    }
+    return stopped;
   }
   async startDev(threadRef, scriptName) {
     const thread = this.requireThread(threadRef);
@@ -14511,11 +14534,21 @@ var Orchestrator = class {
       const off = this.on((event) => {
         if (event.type === "turn_finished" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
         if (event.type === "error" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
       });
       const timer = setInterval(() => {
@@ -14525,7 +14558,13 @@ var Orchestrator = class {
           reject(new Error("wait_for_turn timed out"));
         }
         const current = readThread(thread.id);
-        if (current && !["running", "queued"].includes(current.status)) {
+        if (!current) {
+          clearInterval(timer);
+          off();
+          reject(new Error(`Thread not found: ${thread.id}`));
+          return;
+        }
+        if (!["running", "queued"].includes(current.status)) {
           clearInterval(timer);
           off();
           resolve(current);

package/dist/mcp/run-stdio.js

@@ -3300,23 +3300,24 @@ async function countUnpushedCommits(worktreePath) {
     reject: false
   });
   const branch = head.stdout.trim();
+  if (branch && branch !== "HEAD") {
+    const remote = await git(
+      ["rev-list", "--count", `origin/${branch}..HEAD`],
+      worktreePath,
+      { reject: false }
+    );
+    if (remote.exitCode === 0) {
+      const n2 = Number(remote.stdout.trim());
+      return Number.isFinite(n2) ? n2 : 0;
+    }
+  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
     { reject: false }
   );
-  if (upstream.exitCode === 0) {
-    const n2 = Number(upstream.stdout.trim());
-    return Number.isFinite(n2) ? n2 : 0;
-  }
-  if (!branch || branch === "HEAD") return 0;
-  const remote = await git(
-    ["rev-list", "--count", `origin/${branch}..HEAD`],
-    worktreePath,
-    { reject: false }
-  );
-  if (remote.exitCode !== 0) return 0;
-  const n = Number(remote.stdout.trim());
+  if (upstream.exitCode !== 0) return 0;
+  const n = Number(upstream.stdout.trim());
   return Number.isFinite(n) ? n : 0;
 }
 function splitCombinedDiff(stdout) {
@@ -4626,6 +4627,11 @@ function isPidAlive(pid) {
     return false;
   }
 }
+function writeLiveStatus(threadId, status, lastError) {
+  const latest = readThread(threadId);
+  if (!latest || latest.status === "archived") return latest;
+  return setStatus(threadId, status, lastError);
+}
 var Orchestrator = class {
   events = new EventEmitter();
   processes = /* @__PURE__ */ new Map();
@@ -4931,6 +4937,9 @@ var Orchestrator = class {
   }
   async send(threadRef, prompt) {
     const thread = this.requireThread(threadRef);
+    if (thread.status === "archived") {
+      throw new Error(`Thread is archived: ${thread.id}`);
+    }
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
       const queue = [...current.queue, prompt];
@@ -5024,7 +5033,7 @@ var Orchestrator = class {
           break;
         }
         const thread = readThread(threadId);
-        if (!thread || thread.queue.length === 0) {
+        if (!thread || thread.status === "archived" || thread.queue.length === 0) {
           if (thread && thread.status === "queued") {
             setStatus(threadId, "idle");
             this.emit({ type: "status_changed", threadId, status: "idle" });
@@ -5055,14 +5064,17 @@ var Orchestrator = class {
     }
   }
   async runTurn(threadId, prompt) {
-    let thread = this.requireThread(threadId);
+    const existing = readThread(threadId);
+    if (!existing || existing.status === "archived") return;
+    let thread = existing;
     if (isGlobalThread(thread) && thread.sessionId && orchestratorSessionPoisonedByBuiltins(thread)) {
       thread = updateThread(threadId, { sessionId: null });
     }
+    const running = writeLiveStatus(threadId, "running");
+    if (!running || running.status !== "running") return;
     this.runningCount += 1;
     const turnStartedAt = Date.now();
     this.startingTurns.add(threadId);
-    setStatus(threadId, "running");
     this.emit({ type: "status_changed", threadId, status: "running" });
     this.emit({ type: "turn_started", threadId, prompt });
     try {
@@ -5333,8 +5345,8 @@ var Orchestrator = class {
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
-      const afterTurn = this.requireThread(threadId);
-      if (afterTurn.planMode && afterTurn.worktreePath?.trim()) {
+      const afterTurn = readThread(threadId);
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.worktreePath?.trim()) {
         const presented = extractPresentedPlan(parts);
         const exited = parts.some(
           (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
@@ -5347,29 +5359,34 @@ var Orchestrator = class {
           }
         }
       }
-      if (afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
+      if (afterTurn && afterTurn.status !== "archived" && afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
         (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
       )) {
         updateThread(threadId, { sessionId: null });
       }
       await syncThreadBranchFromGit(threadId);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
       } else {
         const failDetail = formatTurnExitError(exitCode, detail);
         const explainedInChat = exitCode !== 0 && Boolean(chatText) && (looksLikeAgentFailureMessage(chatText) || failDetail && chatText.includes(failDetail.replace(/^exit\s*\d+:\s*/i, "").trim()));
-        setStatus(
+        const nextStatus = exitCode === 0 ? "idle" : "error";
+        const written = writeLiveStatus(
           threadId,
-          exitCode === 0 ? "idle" : "error",
+          nextStatus,
           exitCode === 0 || explainedInChat ? null : failDetail
         );
-        this.emit({
-          type: "status_changed",
-          threadId,
-          status: exitCode === 0 ? "idle" : "error"
-        });
+        if (written && written.status !== "archived") {
+          this.emit({
+            type: "status_changed",
+            threadId,
+            status: written.status
+          });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode });
         if (exitCode !== 0) {
           const blob = [chatText, detail].filter(Boolean).join("\n");
@@ -5380,13 +5397,17 @@ var Orchestrator = class {
       const message = err instanceof Error ? err.message : String(err);
       await syncThreadBranchFromGit(threadId).catch(() => void 0);
       if (this.stoppedTurns.has(threadId)) {
-        setStatus(threadId, "stopped");
-        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        const stopped = writeLiveStatus(threadId, "stopped");
+        if (stopped?.status === "stopped") {
+          this.emit({ type: "status_changed", threadId, status: "stopped" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
       } else {
-        setStatus(threadId, "error", message);
-        this.emit({ type: "error", threadId, message });
-        this.emit({ type: "status_changed", threadId, status: "error" });
+        const written = writeLiveStatus(threadId, "error", message);
+        if (written?.status === "error") {
+          this.emit({ type: "error", threadId, message });
+          this.emit({ type: "status_changed", threadId, status: "error" });
+        }
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
         void this.maybeHandleOrchestrationQuotaFailover(threadId, message);
       }
@@ -5433,9 +5454,11 @@ var Orchestrator = class {
     if (handle) handle.kill();
     const proc = this.processes.get(`${thread.id}:agent`);
     if (proc) proc.kill();
-    setStatus(thread.id, "stopped");
-    this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
-    return this.requireThread(thread.id);
+    const stopped = writeLiveStatus(thread.id, "stopped") ?? readThread(thread.id) ?? thread;
+    if (stopped.status === "stopped") {
+      this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+    }
+    return stopped;
   }
   async startDev(threadRef, scriptName) {
     const thread = this.requireThread(threadRef);
@@ -5671,11 +5694,21 @@ var Orchestrator = class {
       const off = this.on((event) => {
         if (event.type === "turn_finished" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
         if (event.type === "error" && event.threadId === thread.id) {
           off();
-          resolve(this.requireThread(thread.id));
+          const latest = readThread(thread.id);
+          if (!latest) {
+            reject(new Error(`Thread not found: ${thread.id}`));
+            return;
+          }
+          resolve(latest);
         }
       });
       const timer = setInterval(() => {
@@ -5685,7 +5718,13 @@ var Orchestrator = class {
           reject(new Error("wait_for_turn timed out"));
         }
         const current = readThread(thread.id);
-        if (current && !["running", "queued"].includes(current.status)) {
+        if (!current) {
+          clearInterval(timer);
+          off();
+          reject(new Error(`Thread not found: ${thread.id}`));
+          return;
+        }
+        if (!["running", "queued"].includes(current.status)) {
           clearInterval(timer);
           off();
           resolve(current);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sideboard-ai/core",
-  "version": "0.1.95",
+  "version": "0.1.97",
   "description": "Sideboard core — orchestration, agents, git worktrees, MCP server",
   "license": "Apache-2.0",
   "type": "module",