@sideboard-ai/core 0.1.52 → 0.1.53

package/dist/agents/cursor-runner.cjs

@@ -171,6 +171,33 @@ function localAgentStore() {
   (0, import_node_fs3.mkdirSync)(root, { recursive: true });
   return new import_sdk.JsonlLocalAgentStore(root);
 }
+function isAgentBusyError(err) {
+  if (err instanceof import_sdk.AgentBusyError) return true;
+  const message = err instanceof Error ? err.message : String(err);
+  return /already has active run/i.test(message);
+}
+async function cancelStaleLocalRuns(agentId, opts) {
+  const listed = await import_sdk.Agent.listRuns(agentId, {
+    runtime: "local",
+    cwd: opts.cwd,
+    store: opts.store,
+    limit: 20
+  });
+  let cancelled = 0;
+  for (const run of listed.items) {
+    if (run.status !== "running") continue;
+    try {
+      await import_sdk.Agent.cancelRun(run.id, {
+        runtime: "local",
+        cwd: opts.cwd,
+        store: opts.store
+      });
+      cancelled += 1;
+    } catch {
+    }
+  }
+  return cancelled;
+}
 async function readStdinJson() {
   const rl = (0, import_node_readline.createInterface)({ input: process.stdin, crlfDelay: Infinity });
   const chunks = [];
@@ -242,10 +269,22 @@ async function main() {
     }
     try {
       emit({ type: "session_id", data: agent.agentId });
-      const run = await agent.send(
-        req.prompt,
-        mcpServers ? { mcpServers } : void 0
-      );
+      const sendOpts = mcpServers ? { mcpServers } : void 0;
+      let run;
+      try {
+        run = await agent.send(req.prompt, sendOpts);
+      } catch (err) {
+        if (!isAgentBusyError(err)) throw err;
+        const n = await cancelStaleLocalRuns(agent.agentId, {
+          cwd: req.cwd,
+          store
+        });
+        emit({
+          type: "stderr",
+          data: n > 0 ? `Cursor agent had ${n} stale active run(s) \u2014 cancelled and retrying` : "Cursor agent busy \u2014 retrying send"
+        });
+        run = await agent.send(req.prompt, sendOpts);
+      }
       for await (const msg of run.stream()) {
         for (const event of cursorSdkMessageToEvents(msg)) {
           emit(event);

package/dist/agents/cursor-runner.js

@@ -2,13 +2,13 @@
 import {
   cursorSdkMessageToEvents,
   formatUnknownDetail
-} from "../chunk-J5JTEJ5O.js";
+} from "../chunk-VG22SETP.js";
 import {
   appDataDir
 } from "../chunk-M37RITA6.js";
 
 // src/agents/cursor-runner.ts
-import { Agent, CursorAgentError, JsonlLocalAgentStore } from "@cursor/sdk";
+import { Agent, AgentBusyError, CursorAgentError, JsonlLocalAgentStore } from "@cursor/sdk";
 import { mkdirSync } from "fs";
 import { join } from "path";
 import { createInterface } from "readline";
@@ -35,6 +35,33 @@ function localAgentStore() {
   mkdirSync(root, { recursive: true });
   return new JsonlLocalAgentStore(root);
 }
+function isAgentBusyError(err) {
+  if (err instanceof AgentBusyError) return true;
+  const message = err instanceof Error ? err.message : String(err);
+  return /already has active run/i.test(message);
+}
+async function cancelStaleLocalRuns(agentId, opts) {
+  const listed = await Agent.listRuns(agentId, {
+    runtime: "local",
+    cwd: opts.cwd,
+    store: opts.store,
+    limit: 20
+  });
+  let cancelled = 0;
+  for (const run of listed.items) {
+    if (run.status !== "running") continue;
+    try {
+      await Agent.cancelRun(run.id, {
+        runtime: "local",
+        cwd: opts.cwd,
+        store: opts.store
+      });
+      cancelled += 1;
+    } catch {
+    }
+  }
+  return cancelled;
+}
 async function readStdinJson() {
   const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
   const chunks = [];
@@ -106,10 +133,22 @@ async function main() {
     }
     try {
       emit({ type: "session_id", data: agent.agentId });
-      const run = await agent.send(
-        req.prompt,
-        mcpServers ? { mcpServers } : void 0
-      );
+      const sendOpts = mcpServers ? { mcpServers } : void 0;
+      let run;
+      try {
+        run = await agent.send(req.prompt, sendOpts);
+      } catch (err) {
+        if (!isAgentBusyError(err)) throw err;
+        const n = await cancelStaleLocalRuns(agent.agentId, {
+          cwd: req.cwd,
+          store
+        });
+        emit({
+          type: "stderr",
+          data: n > 0 ? `Cursor agent had ${n} stale active run(s) \u2014 cancelled and retrying` : "Cursor agent busy \u2014 retrying send"
+        });
+        run = await agent.send(req.prompt, sendOpts);
+      }
       for await (const msg of run.stream()) {
         for (const event of cursorSdkMessageToEvents(msg)) {
           emit(event);

package/dist/{agents-ON6RKKND.js → agents-KP7UJEHJ.js}

@@ -30,7 +30,7 @@ import {
   permissionMode,
   resolveCursorModelId,
   resolveQuotaFallbackAgent
-} from "./chunk-6QTZVJ7A.js";
+} from "./chunk-BZST4HMJ.js";
 import "./chunk-H6GGDLYS.js";
 import "./chunk-HBJSHRY2.js";
 import {

package/dist/{agents-YKSS6VBO.js → agents-KYACODJ3.js}

@@ -26,7 +26,7 @@ import {
   permissionMode,
   resolveCursorModelId,
   resolveQuotaFallbackAgent
-} from "./chunk-D3METLRW.js";
+} from "./chunk-A6HVEMIB.js";
 import {
   ORCHESTRATOR_AGENT_KINDS,
   assertOrchestratorCapableAgent,
@@ -37,7 +37,7 @@ import "./chunk-BXJ76RHF.js";
 import {
   cursorSdkMessageToEvents,
   parseCursorRunnerLine
-} from "./chunk-J5JTEJ5O.js";
+} from "./chunk-VG22SETP.js";
 import "./chunk-T5QQVXK3.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-M37RITA6.js";

package/dist/{chunk-D3METLRW.js → chunk-A6HVEMIB.js}

@@ -10,7 +10,7 @@ import {
   formatUnknownDetail,
   looksLikeAgentFailureMessage,
   parseCursorRunnerLine
-} from "./chunk-J5JTEJ5O.js";
+} from "./chunk-VG22SETP.js";
 import {
   claudeChromeEnabled,
   loadAppSettings,
@@ -1609,6 +1609,7 @@ var opencodeAdapter = {
     }
   },
   async resolveSessionId(worktreePath, cached) {
+    const cachedId = cached?.trim() || null;
     const listed = await run(
       "opencode",
       ["session", "list", "--format", "json"],
@@ -1620,15 +1621,21 @@ var opencodeAdapter = {
         if (Array.isArray(sessions) && sessions.length > 0) {
           const norm = (p) => p.replace(/\/+$/, "");
           const wt = norm(worktreePath);
-          const match = sessions.find(
+          const forWorktree = sessions.filter(
             (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
           );
-          if (match?.id) return match.id;
+          if (cachedId && forWorktree.some((s) => s.id === cachedId)) {
+            return cachedId;
+          }
+          if (cachedId && sessions.some((s) => s.id === cachedId)) {
+            return cachedId;
+          }
+          return null;
         }
       } catch {
       }
     }
-    return cached;
+    return cachedId;
   },
   async buildAttach(thread) {
     const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);

package/dist/{chunk-6QTZVJ7A.js → chunk-BZST4HMJ.js}

@@ -109,6 +109,11 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
+function looksLikeInvalidAgentSession(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
+}
 function looksLikeAgentFailureMessage(text) {
   const lower = text.trim().toLowerCase();
   if (!lower) return false;
@@ -1766,6 +1771,7 @@ var opencodeAdapter = {
     }
   },
   async resolveSessionId(worktreePath, cached) {
+    const cachedId = cached?.trim() || null;
     const listed = await run(
       "opencode",
       ["session", "list", "--format", "json"],
@@ -1777,15 +1783,21 @@ var opencodeAdapter = {
         if (Array.isArray(sessions) && sessions.length > 0) {
           const norm = (p) => p.replace(/\/+$/, "");
           const wt = norm(worktreePath);
-          const match = sessions.find(
+          const forWorktree = sessions.filter(
             (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
           );
-          if (match?.id) return match.id;
+          if (cachedId && forWorktree.some((s) => s.id === cachedId)) {
+            return cachedId;
+          }
+          if (cachedId && sessions.some((s) => s.id === cachedId)) {
+            return cachedId;
+          }
+          return null;
         }
       } catch {
       }
     }
-    return cached;
+    return cachedId;
   },
   async buildAttach(thread) {
     const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
@@ -2197,6 +2209,7 @@ function allAdapters() {
 export {
   pushTurnStderr,
   summarizeTurnStderr,
+  looksLikeInvalidAgentSession,
   looksLikeAgentFailureMessage,
   fallbackTurnFailDetail,
   humanizeAgentFailDetail,

package/dist/{chunk-J5JTEJ5O.js → chunk-VG22SETP.js}

@@ -60,6 +60,11 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
+function looksLikeInvalidAgentSession(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
+}
 function looksLikeAgentFailureMessage(text) {
   const lower = text.trim().toLowerCase();
   if (!lower) return false;
@@ -212,6 +217,7 @@ export {
   extractJsonErrorMessage,
   pushTurnStderr,
   summarizeTurnStderr,
+  looksLikeInvalidAgentSession,
   looksLikeAgentFailureMessage,
   fallbackTurnFailDetail,
   humanizeAgentFailDetail,

package/dist/index.cjs

@@ -4316,6 +4316,11 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
+function looksLikeInvalidAgentSession(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
+}
 function looksLikeAgentFailureMessage(text) {
   const lower = text.trim().toLowerCase();
   if (!lower) return false;
@@ -6124,6 +6129,7 @@ var init_opencode = __esm({
         }
       },
       async resolveSessionId(worktreePath, cached) {
+        const cachedId = cached?.trim() || null;
         const listed = await run(
           "opencode",
           ["session", "list", "--format", "json"],
@@ -6135,15 +6141,21 @@ var init_opencode = __esm({
             if (Array.isArray(sessions) && sessions.length > 0) {
               const norm = (p) => p.replace(/\/+$/, "");
               const wt = norm(worktreePath);
-              const match = sessions.find(
+              const forWorktree = sessions.filter(
                 (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
               );
-              if (match?.id) return match.id;
+              if (cachedId && forWorktree.some((s) => s.id === cachedId)) {
+                return cachedId;
+              }
+              if (cachedId && sessions.some((s) => s.id === cachedId)) {
+                return cachedId;
+              }
+              return null;
             }
           } catch {
           }
         }
-        return cached;
+        return cachedId;
       },
       async buildAttach(thread) {
         const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
@@ -11570,21 +11582,30 @@ var Orchestrator = class {
     return findThreadByRef(idOrRef) ?? readThread(idOrRef);
   }
   async createThread(input) {
-    let thread = await createThread(input);
+    const thread = await createThread(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.finishCreateThread(thread.id, input.prompt?.trim() || void 0);
+    return thread;
+  }
+  async finishCreateThread(threadId, prompt) {
+    await this.runSetupAfterCreate(threadId);
     const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
     if (autoRunAfterSetupEnabled2()) {
       try {
-        await this.startDev(thread.id);
+        await this.startDev(threadId);
       } catch {
       }
     }
-    const prompt = input.prompt?.trim();
     if (prompt) {
-      thread = await this.send(thread.id, prompt);
+      try {
+        await this.send(threadId, prompt);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        updateThread(threadId, {
+          lastError: `First prompt failed: ${message}`
+        });
+      }
     }
-    return thread;
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -11930,8 +11951,73 @@ var Orchestrator = class {
           }
         }
       }
-      const lastStderr = summarizeTurnStderr(stderrTail);
-      const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      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 !== "cursor" && this.requireThread(threadId).agent !== "brightsy") {
+        updateThread(threadId, { sessionId: null });
+        pushTurnStderr(
+          stderrTail,
+          "Agent session missing \u2014 starting a fresh session"
+        );
+        this.emit({
+          type: "turn_output",
+          threadId,
+          event: {
+            type: "stderr",
+            data: "Agent session missing \u2014 starting a fresh session"
+          }
+        });
+        const retryThread = this.requireThread(threadId);
+        const prior = retryThread.messages.slice(0, -1);
+        const retrySeed = buildSessionSeed(prior);
+        const retryInstructions = retryThread.agent === "claude" ? null : formatAgentInstructions(
+          loadAgentInstructions(retryThread.worktreePath, retryThread.agent)
+        );
+        const retryPrefix = [
+          coordinatorDirective,
+          worktreeDirective,
+          artifactDirective,
+          renameBranchDirective,
+          retryInstructions,
+          retrySeed
+        ].filter(Boolean).join("\n\n---\n\n");
+        const retryHandle = await spawnAgentTurn(
+          retryThread,
+          { cachedPrefix: retryPrefix, prompt: agentPrompt },
+          (event) => {
+            this.emit({ type: "turn_output", threadId, event });
+            if (event.type === "session_id") {
+              updateThread(threadId, { sessionId: event.data });
+            }
+            if (event.type === "stderr" && typeof event.data === "string") {
+              pushTurnStderr(stderrTail, event.data);
+            }
+          }
+        );
+        this.activeTurns.set(threadId, retryHandle);
+        if (typeof retryHandle.pid === "number" && retryHandle.pid > 0) {
+          updateThread(threadId, { agentPid: retryHandle.pid });
+        }
+        this.processes.set(`${threadId}:agent`, {
+          kind: "agent",
+          pid: retryHandle.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          kill: retryHandle.kill
+        });
+        if (this.stoppedTurns.has(threadId)) {
+          retryHandle.kill();
+        }
+        const retryResult = await retryHandle.done;
+        if (retryResult.sessionId) {
+          updateThread(threadId, { sessionId: retryResult.sessionId });
+        }
+        assistantText = retryResult.assistantText.trim();
+        parts = retryResult.parts;
+        usage = retryResult.usage ?? void 0;
+        exitCode = retryResult.exitCode;
+        lastStderr = summarizeTurnStderr(stderrTail);
+        detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      }
       let chatText = assistantText;
       if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
         chatText = humanizeAgentFailDetail(detail);

package/dist/index.d.cts

@@ -2223,6 +2223,7 @@ declare class Orchestrator {
     getThreads(includeArchived?: boolean): Thread[];
     getThread(idOrRef: string): Thread | null;
     createThread(input: CreateThreadInput): Promise<Thread>;
+    private finishCreateThread;
     /** Run workspace setup after a new worktree is created (no-op if none configured). */
     private runSetupAfterCreate;
     listWorkspaces(): Workspace[];

package/dist/index.d.ts

@@ -2223,6 +2223,7 @@ declare class Orchestrator {
     getThreads(includeArchived?: boolean): Thread[];
     getThread(idOrRef: string): Thread | null;
     createThread(input: CreateThreadInput): Promise<Thread>;
+    private finishCreateThread;
     /** Run workspace setup after a new worktree is created (no-op if none configured). */
     private runSetupAfterCreate;
     listWorkspaces(): Workspace[];

package/dist/index.js

@@ -70,7 +70,7 @@ import {
   resolveQuotaFallbackAgent,
   sanitizeMcpServerName,
   writeInjectedMcpConfig
-} from "./chunk-D3METLRW.js";
+} from "./chunk-A6HVEMIB.js";
 import {
   ORCHESTRATOR_AGENT_KINDS,
   assertOrchestratorCapableAgent,
@@ -106,10 +106,11 @@ import {
   formatTurnExitError,
   humanizeAgentFailDetail,
   looksLikeAgentFailureMessage,
+  looksLikeInvalidAgentSession,
   parseCursorRunnerLine,
   pushTurnStderr,
   summarizeTurnStderr
-} from "./chunk-J5JTEJ5O.js";
+} from "./chunk-VG22SETP.js";
 import {
   HARNESS_ENV_KEYS,
   appSettingsPath,
@@ -2941,7 +2942,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-YKSS6VBO.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-KYACODJ3.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -4544,21 +4545,30 @@ var Orchestrator = class {
     return findThreadByRef(idOrRef) ?? readThread(idOrRef);
   }
   async createThread(input) {
-    let thread = await createThread(input);
+    const thread = await createThread(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.finishCreateThread(thread.id, input.prompt?.trim() || void 0);
+    return thread;
+  }
+  async finishCreateThread(threadId, prompt) {
+    await this.runSetupAfterCreate(threadId);
     const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await import("./app-settings-LZP632KI.js");
     if (autoRunAfterSetupEnabled2()) {
       try {
-        await this.startDev(thread.id);
+        await this.startDev(threadId);
       } catch {
       }
     }
-    const prompt = input.prompt?.trim();
     if (prompt) {
-      thread = await this.send(thread.id, prompt);
+      try {
+        await this.send(threadId, prompt);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        updateThread(threadId, {
+          lastError: `First prompt failed: ${message}`
+        });
+      }
     }
-    return thread;
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -4904,8 +4914,73 @@ var Orchestrator = class {
           }
         }
       }
-      const lastStderr = summarizeTurnStderr(stderrTail);
-      const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      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 !== "cursor" && this.requireThread(threadId).agent !== "brightsy") {
+        updateThread(threadId, { sessionId: null });
+        pushTurnStderr(
+          stderrTail,
+          "Agent session missing \u2014 starting a fresh session"
+        );
+        this.emit({
+          type: "turn_output",
+          threadId,
+          event: {
+            type: "stderr",
+            data: "Agent session missing \u2014 starting a fresh session"
+          }
+        });
+        const retryThread = this.requireThread(threadId);
+        const prior = retryThread.messages.slice(0, -1);
+        const retrySeed = buildSessionSeed(prior);
+        const retryInstructions = retryThread.agent === "claude" ? null : formatAgentInstructions(
+          loadAgentInstructions(retryThread.worktreePath, retryThread.agent)
+        );
+        const retryPrefix = [
+          coordinatorDirective,
+          worktreeDirective,
+          artifactDirective,
+          renameBranchDirective,
+          retryInstructions,
+          retrySeed
+        ].filter(Boolean).join("\n\n---\n\n");
+        const retryHandle = await spawnAgentTurn(
+          retryThread,
+          { cachedPrefix: retryPrefix, prompt: agentPrompt },
+          (event) => {
+            this.emit({ type: "turn_output", threadId, event });
+            if (event.type === "session_id") {
+              updateThread(threadId, { sessionId: event.data });
+            }
+            if (event.type === "stderr" && typeof event.data === "string") {
+              pushTurnStderr(stderrTail, event.data);
+            }
+          }
+        );
+        this.activeTurns.set(threadId, retryHandle);
+        if (typeof retryHandle.pid === "number" && retryHandle.pid > 0) {
+          updateThread(threadId, { agentPid: retryHandle.pid });
+        }
+        this.processes.set(`${threadId}:agent`, {
+          kind: "agent",
+          pid: retryHandle.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          kill: retryHandle.kill
+        });
+        if (this.stoppedTurns.has(threadId)) {
+          retryHandle.kill();
+        }
+        const retryResult = await retryHandle.done;
+        if (retryResult.sessionId) {
+          updateThread(threadId, { sessionId: retryResult.sessionId });
+        }
+        assistantText = retryResult.assistantText.trim();
+        parts = retryResult.parts;
+        usage = retryResult.usage ?? void 0;
+        exitCode = retryResult.exitCode;
+        lastStderr = summarizeTurnStderr(stderrTail);
+        detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      }
       let chatText = assistantText;
       if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
         chatText = humanizeAgentFailDetail(detail);

package/dist/mcp/run-stdio.cjs

@@ -92,6 +92,11 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
+function looksLikeInvalidAgentSession(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
+}
 function looksLikeAgentFailureMessage(text) {
   const lower = text.trim().toLowerCase();
   if (!lower) return false;
@@ -5710,6 +5715,7 @@ var init_opencode = __esm({
         }
       },
       async resolveSessionId(worktreePath, cached) {
+        const cachedId = cached?.trim() || null;
         const listed = await run(
           "opencode",
           ["session", "list", "--format", "json"],
@@ -5721,15 +5727,21 @@ var init_opencode = __esm({
             if (Array.isArray(sessions) && sessions.length > 0) {
               const norm = (p) => p.replace(/\/+$/, "");
               const wt = norm(worktreePath);
-              const match = sessions.find(
+              const forWorktree = sessions.filter(
                 (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
               );
-              if (match?.id) return match.id;
+              if (cachedId && forWorktree.some((s) => s.id === cachedId)) {
+                return cachedId;
+              }
+              if (cachedId && sessions.some((s) => s.id === cachedId)) {
+                return cachedId;
+              }
+              return null;
             }
           } catch {
           }
         }
-        return cached;
+        return cachedId;
       },
       async buildAttach(thread) {
         const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
@@ -10479,21 +10491,30 @@ var Orchestrator = class {
     return findThreadByRef(idOrRef) ?? readThread(idOrRef);
   }
   async createThread(input) {
-    let thread = await createThread(input);
+    const thread = await createThread(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.finishCreateThread(thread.id, input.prompt?.trim() || void 0);
+    return thread;
+  }
+  async finishCreateThread(threadId, prompt) {
+    await this.runSetupAfterCreate(threadId);
     const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
     if (autoRunAfterSetupEnabled2()) {
       try {
-        await this.startDev(thread.id);
+        await this.startDev(threadId);
       } catch {
       }
     }
-    const prompt = input.prompt?.trim();
     if (prompt) {
-      thread = await this.send(thread.id, prompt);
+      try {
+        await this.send(threadId, prompt);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        updateThread(threadId, {
+          lastError: `First prompt failed: ${message}`
+        });
+      }
     }
-    return thread;
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -10839,8 +10860,73 @@ var Orchestrator = class {
           }
         }
       }
-      const lastStderr = summarizeTurnStderr(stderrTail);
-      const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      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 !== "cursor" && this.requireThread(threadId).agent !== "brightsy") {
+        updateThread(threadId, { sessionId: null });
+        pushTurnStderr(
+          stderrTail,
+          "Agent session missing \u2014 starting a fresh session"
+        );
+        this.emit({
+          type: "turn_output",
+          threadId,
+          event: {
+            type: "stderr",
+            data: "Agent session missing \u2014 starting a fresh session"
+          }
+        });
+        const retryThread = this.requireThread(threadId);
+        const prior = retryThread.messages.slice(0, -1);
+        const retrySeed = buildSessionSeed(prior);
+        const retryInstructions = retryThread.agent === "claude" ? null : formatAgentInstructions(
+          loadAgentInstructions(retryThread.worktreePath, retryThread.agent)
+        );
+        const retryPrefix = [
+          coordinatorDirective,
+          worktreeDirective,
+          artifactDirective,
+          renameBranchDirective,
+          retryInstructions,
+          retrySeed
+        ].filter(Boolean).join("\n\n---\n\n");
+        const retryHandle = await spawnAgentTurn(
+          retryThread,
+          { cachedPrefix: retryPrefix, prompt: agentPrompt },
+          (event) => {
+            this.emit({ type: "turn_output", threadId, event });
+            if (event.type === "session_id") {
+              updateThread(threadId, { sessionId: event.data });
+            }
+            if (event.type === "stderr" && typeof event.data === "string") {
+              pushTurnStderr(stderrTail, event.data);
+            }
+          }
+        );
+        this.activeTurns.set(threadId, retryHandle);
+        if (typeof retryHandle.pid === "number" && retryHandle.pid > 0) {
+          updateThread(threadId, { agentPid: retryHandle.pid });
+        }
+        this.processes.set(`${threadId}:agent`, {
+          kind: "agent",
+          pid: retryHandle.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          kill: retryHandle.kill
+        });
+        if (this.stoppedTurns.has(threadId)) {
+          retryHandle.kill();
+        }
+        const retryResult = await retryHandle.done;
+        if (retryResult.sessionId) {
+          updateThread(threadId, { sessionId: retryResult.sessionId });
+        }
+        assistantText = retryResult.assistantText.trim();
+        parts = retryResult.parts;
+        usage = retryResult.usage ?? void 0;
+        exitCode = retryResult.exitCode;
+        lastStderr = summarizeTurnStderr(stderrTail);
+        detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      }
       let chatText = assistantText;
       if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
         chatText = humanizeAgentFailDetail(detail);

package/dist/mcp/run-stdio.js

@@ -10,12 +10,13 @@ import {
   isSessionQuotaLimit,
   listModelsForAgent,
   looksLikeAgentFailureMessage,
+  looksLikeInvalidAgentSession,
   parseBrightsyCliLine,
   parseSessionQuotaResetAt,
   pushTurnStderr,
   resolveQuotaFallbackAgent,
   summarizeTurnStderr
-} from "../chunk-6QTZVJ7A.js";
+} from "../chunk-BZST4HMJ.js";
 import "../chunk-H6GGDLYS.js";
 import {
   addWorkspace,
@@ -1162,7 +1163,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-ON6RKKND.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-KP7UJEHJ.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -4037,21 +4038,30 @@ var Orchestrator = class {
     return findThreadByRef(idOrRef) ?? readThread(idOrRef);
   }
   async createThread(input) {
-    let thread = await createThread(input);
+    const thread = await createThread(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.finishCreateThread(thread.id, input.prompt?.trim() || void 0);
+    return thread;
+  }
+  async finishCreateThread(threadId, prompt) {
+    await this.runSetupAfterCreate(threadId);
     const { autoRunAfterSetupEnabled } = await import("../app-settings-7XVDQJ7F.js");
     if (autoRunAfterSetupEnabled()) {
       try {
-        await this.startDev(thread.id);
+        await this.startDev(threadId);
       } catch {
       }
     }
-    const prompt = input.prompt?.trim();
     if (prompt) {
-      thread = await this.send(thread.id, prompt);
+      try {
+        await this.send(threadId, prompt);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        updateThread(threadId, {
+          lastError: `First prompt failed: ${message}`
+        });
+      }
     }
-    return thread;
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -4397,8 +4407,73 @@ var Orchestrator = class {
           }
         }
       }
-      const lastStderr = summarizeTurnStderr(stderrTail);
-      const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      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 !== "cursor" && this.requireThread(threadId).agent !== "brightsy") {
+        updateThread(threadId, { sessionId: null });
+        pushTurnStderr(
+          stderrTail,
+          "Agent session missing \u2014 starting a fresh session"
+        );
+        this.emit({
+          type: "turn_output",
+          threadId,
+          event: {
+            type: "stderr",
+            data: "Agent session missing \u2014 starting a fresh session"
+          }
+        });
+        const retryThread = this.requireThread(threadId);
+        const prior = retryThread.messages.slice(0, -1);
+        const retrySeed = buildSessionSeed(prior);
+        const retryInstructions = retryThread.agent === "claude" ? null : formatAgentInstructions(
+          loadAgentInstructions(retryThread.worktreePath, retryThread.agent)
+        );
+        const retryPrefix = [
+          coordinatorDirective,
+          worktreeDirective,
+          artifactDirective,
+          renameBranchDirective,
+          retryInstructions,
+          retrySeed
+        ].filter(Boolean).join("\n\n---\n\n");
+        const retryHandle = await spawnAgentTurn(
+          retryThread,
+          { cachedPrefix: retryPrefix, prompt: agentPrompt },
+          (event) => {
+            this.emit({ type: "turn_output", threadId, event });
+            if (event.type === "session_id") {
+              updateThread(threadId, { sessionId: event.data });
+            }
+            if (event.type === "stderr" && typeof event.data === "string") {
+              pushTurnStderr(stderrTail, event.data);
+            }
+          }
+        );
+        this.activeTurns.set(threadId, retryHandle);
+        if (typeof retryHandle.pid === "number" && retryHandle.pid > 0) {
+          updateThread(threadId, { agentPid: retryHandle.pid });
+        }
+        this.processes.set(`${threadId}:agent`, {
+          kind: "agent",
+          pid: retryHandle.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          kill: retryHandle.kill
+        });
+        if (this.stoppedTurns.has(threadId)) {
+          retryHandle.kill();
+        }
+        const retryResult = await retryHandle.done;
+        if (retryResult.sessionId) {
+          updateThread(threadId, { sessionId: retryResult.sessionId });
+        }
+        assistantText = retryResult.assistantText.trim();
+        parts = retryResult.parts;
+        usage = retryResult.usage ?? void 0;
+        exitCode = retryResult.exitCode;
+        lastStderr = summarizeTurnStderr(stderrTail);
+        detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      }
       let chatText = assistantText;
       if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
         chatText = humanizeAgentFailDetail(detail);

package/package.json

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