@sideboard-ai/core 0.1.39 → 0.1.42

package/dist/agents/cursor-runner.cjs

@@ -198,18 +198,35 @@ async function main() {
   const store = localAgentStore();
   const local = { cwd: req.cwd, store };
   try {
-    const agent = req.agentId ? await import_sdk.Agent.resume(req.agentId, {
-      apiKey,
-      model,
-      mode,
-      local
-    }) : await import_sdk.Agent.create({
-      apiKey,
-      model,
-      mode,
-      local,
-      name: "Sideboard"
-    });
+    let agent;
+    try {
+      agent = req.agentId ? await import_sdk.Agent.resume(req.agentId, {
+        apiKey,
+        model,
+        mode,
+        local
+      }) : await import_sdk.Agent.create({
+        apiKey,
+        model,
+        mode,
+        local,
+        name: "Sideboard"
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!req.agentId || !/not found/i.test(message)) throw err;
+      emit({
+        type: "stderr",
+        data: `Cursor agent ${req.agentId} not found \u2014 starting a new session`
+      });
+      agent = await import_sdk.Agent.create({
+        apiKey,
+        model,
+        mode,
+        local,
+        name: "Sideboard"
+      });
+    }
     try {
       emit({ type: "session_id", data: agent.agentId });
       const run = await agent.send(req.prompt);

package/dist/agents/cursor-runner.js

@@ -62,18 +62,35 @@ async function main() {
   const store = localAgentStore();
   const local = { cwd: req.cwd, store };
   try {
-    const agent = req.agentId ? await Agent.resume(req.agentId, {
-      apiKey,
-      model,
-      mode,
-      local
-    }) : await Agent.create({
-      apiKey,
-      model,
-      mode,
-      local,
-      name: "Sideboard"
-    });
+    let agent;
+    try {
+      agent = req.agentId ? await Agent.resume(req.agentId, {
+        apiKey,
+        model,
+        mode,
+        local
+      }) : await Agent.create({
+        apiKey,
+        model,
+        mode,
+        local,
+        name: "Sideboard"
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!req.agentId || !/not found/i.test(message)) throw err;
+      emit({
+        type: "stderr",
+        data: `Cursor agent ${req.agentId} not found \u2014 starting a new session`
+      });
+      agent = await Agent.create({
+        apiKey,
+        model,
+        mode,
+        local,
+        name: "Sideboard"
+      });
+    }
     try {
       emit({ type: "session_id", data: agent.agentId });
       const run = await agent.send(req.prompt);

package/dist/{agents-DDW4NBBW.js → agents-T6XHC5OV.js}

@@ -21,7 +21,7 @@ import {
   opencodeAdapter,
   permissionMode,
   resolveCursorModelId
-} from "./chunk-BEXVE7LX.js";
+} from "./chunk-SX2R2PCE.js";
 import "./chunk-ILQK4P5R.js";
 import {
   cursorSdkMessageToEvents,

package/dist/{chunk-FVGRUZHI.js → chunk-44LYDJFB.js}

@@ -1,10 +1,10 @@
 import {
   isGlobalRepoPath
-} from "./chunk-IS3AGU33.js";
+} from "./chunk-6TZSJMXF.js";
 import {
   ensureGhPreferOrigin,
   resolveRepoRoot
-} from "./chunk-XBEQI5H4.js";
+} from "./chunk-VA2U5EQH.js";
 import {
   appDataDir
 } from "./chunk-M37RITA6.js";

package/dist/{chunk-HYRHI3QU.js → chunk-5UIKSPDD.js}

@@ -26,6 +26,7 @@ function normalizeThread(raw) {
     planMode: Boolean(raw.planMode),
     autonomy: raw.autonomy ?? "default",
     lastError: raw.lastError ?? null,
+    agentPid: raw.agentPid ?? null,
     attachments: Array.isArray(raw.attachments) ? raw.attachments : [],
     prTitle: raw.prTitle ?? null,
     userSetTitle: Boolean(raw.userSetTitle),
@@ -61,7 +62,8 @@ function createEmptyThread(partial) {
     worktreePath: partial.worktreePath,
     repoPath: partial.repoPath,
     agent: partial.agent,
-    lastError: null
+    lastError: null,
+    agentPid: null
   };
 }
 async function withThreadLock(id, fn) {

package/dist/{chunk-IS3AGU33.js → chunk-6TZSJMXF.js}

@@ -1,17 +1,17 @@
 import {
   ensureGlobalCoordinatorCwd
-} from "./chunk-PTASB7SJ.js";
+} from "./chunk-UPMGXM4X.js";
 import {
   allocateTeamName,
   takenSlugsFromThread,
   teamSlugFromName
-} from "./chunk-XBEQI5H4.js";
+} from "./chunk-VA2U5EQH.js";
 import {
   createEmptyThread,
   listThreads,
   updateThread,
   writeThread
-} from "./chunk-HYRHI3QU.js";
+} from "./chunk-5UIKSPDD.js";
 import {
   globalAgentCwd
 } from "./chunk-M37RITA6.js";

package/dist/{chunk-2YFQNL3O.js → chunk-FZH2SL5I.js}

@@ -3,7 +3,7 @@ import {
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-FVGRUZHI.js";
+} from "./chunk-44LYDJFB.js";
 import {
   GLOBAL_WORKSPACE_ID,
   createGlobalChat,
@@ -13,19 +13,19 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "./chunk-IS3AGU33.js";
+} from "./chunk-6TZSJMXF.js";
 import {
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "./chunk-PTASB7SJ.js";
+} from "./chunk-UPMGXM4X.js";
 import {
   PLAN_MODE_INSTRUCTION,
   allAdapters,
   getAdapter,
   parseBrightsyCliLine
-} from "./chunk-BEXVE7LX.js";
+} from "./chunk-SX2R2PCE.js";
 import {
   fallbackTurnFailDetail,
   formatTurnExitError,
@@ -71,7 +71,7 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeNameFromPath
-} from "./chunk-XBEQI5H4.js";
+} from "./chunk-VA2U5EQH.js";
 import {
   appendMessage,
   createEmptyThread,
@@ -83,7 +83,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-HYRHI3QU.js";
+} from "./chunk-5UIKSPDD.js";
 import {
   loadRepoSettings,
   loadWorkspaceSettings,
@@ -459,9 +459,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-QSRP25HQ.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-4GVWSCEX.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-WIYQVMOG.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-FAILHO4J.js");
     ensureGlobalCoordinatorCwd2();
   }
   const adapter = getAdapter(thread.agent);
@@ -631,6 +631,31 @@ function formatWorktreeDirective(thread, opts) {
       "- Prefer a draft PR first: `gh pr create --draft -R <origin-owner/name>` (or update via `gh pr edit -R \u2026`) once the change set is coherent. Resolve `<origin-owner/name>` with `git remote get-url origin` in this worktree \u2014 never from `upstream`. Mark ready for review only when asked. Title/body must reflect the change purpose, not the worktree name."
     );
   }
+  lines.push("");
+  lines.push(
+    "Short git requests from the Sideboard UI are complete instructions \u2014 expand them using the rules above without asking for clarification:"
+  );
+  lines.push(
+    '- "Commit and push." \u2192 commit any uncommitted work with a purpose-stating message, then push to origin (updates an existing PR if one is linked).'
+  );
+  lines.push(
+    '- "Commit, push, and open a draft PR." \u2192 commit, push, then create a draft PR with `gh pr create --draft -R \u2026` (title/body from the change purpose).'
+  );
+  lines.push(
+    '- "Commit, push, and open a PR in the browser." \u2192 commit, push, then `gh pr create --web -R \u2026`.'
+  );
+  lines.push(
+    '- "Fix CI: <name>." \u2192 investigate that failing check, fix it, commit, and push.'
+  );
+  lines.push(
+    '- "Update the branch." / "Fix merge conflicts." \u2192 sync with the PR base (merge or rebase), resolve conflicts carefully, commit, and push until the PR is mergeable.'
+  );
+  lines.push(
+    '- "Address review comments." \u2192 read PR review feedback, make the requested changes, commit, and push.'
+  );
+  lines.push(
+    '- "Merge PR." \u2192 merge this thread\'s open pull request with `gh pr merge` (respect repo defaults / squash vs merge); do not force-push main/master.'
+  );
   return lines.join("\n");
 }
 function formatArtifactDirective() {
@@ -2614,7 +2639,7 @@ async function createThread(input, onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-DDW4NBBW.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-T6XHC5OV.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2834,7 +2859,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-DMYWHVJC.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-Z7CSL4O6.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -3296,6 +3321,15 @@ async function syncThreadBranchFromGit(threadId) {
 }
 
 // src/orchestrator/orchestrator.ts
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var Orchestrator = class {
   events = new EventEmitter();
   processes = /* @__PURE__ */ new Map();
@@ -3332,8 +3366,18 @@ var Orchestrator = class {
   isStaleRunningThread(threadId, status) {
     return status === "running" && !this.activeTurns.has(threadId) && !this.startingTurns.has(threadId);
   }
+  /**
+   * Cross-process guard: another Sideboard process (MCP stdio) may call reconcile
+   * while the desktop still owns a live agent child. Never reclaim those.
+   */
+  shouldReclaimRunningThread(thread) {
+    if (!this.isStaleRunningThread(thread.id, thread.status)) return false;
+    const pid = thread.agentPid;
+    if (typeof pid === "number" && pid > 0 && isPidAlive(pid)) return false;
+    return true;
+  }
   async reconcile(repoPath, opts) {
-    const reclaimStaleTurns = opts?.reclaimStaleTurns !== false;
+    const reclaimStaleTurns = opts?.reclaimStaleTurns === true;
     healOrchestrationSoccerTitles();
     for (const thread of listThreads({ includeArchived: true })) {
       if (thread.status === "archived") continue;
@@ -3349,7 +3393,7 @@ var Orchestrator = class {
         if (Object.keys(heal).length) {
           updateThread(thread.id, heal);
         }
-        if (reclaimStaleTurns && this.isStaleRunningThread(thread.id, thread.status)) {
+        if (reclaimStaleTurns && this.shouldReclaimRunningThread(thread)) {
           setStatus(thread.id, "stopped", "Process died (reconciled on startup)");
           this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
         }
@@ -3360,7 +3404,7 @@ var Orchestrator = class {
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
       }
-      if (reclaimStaleTurns && this.isStaleRunningThread(thread.id, thread.status)) {
+      if (reclaimStaleTurns && this.shouldReclaimRunningThread(thread)) {
         setStatus(thread.id, "stopped", "Process died (reconciled on startup)");
         this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
       }
@@ -3542,6 +3586,11 @@ var Orchestrator = class {
           await new Promise((r) => setTimeout(r, 100));
           continue;
         }
+        const livePid = thread.agentPid;
+        if (typeof livePid === "number" && livePid > 0 && isPidAlive(livePid)) {
+          await new Promise((r) => setTimeout(r, 200));
+          continue;
+        }
         const prompt = thread.queue[0];
         const remaining = thread.queue.slice(1);
         updateThread(threadId, { queue: remaining });
@@ -3685,10 +3734,18 @@ var Orchestrator = class {
           if (event.type === "stderr" && typeof event.data === "string") {
             pushTurnStderr(stderrTail, event.data);
           }
+          const live = readThread(threadId);
+          if (live?.lastError?.includes("reconciled on startup") && (this.activeTurns.has(threadId) || this.startingTurns.has(threadId))) {
+            setStatus(threadId, "running");
+            this.emit({ type: "status_changed", threadId, status: "running" });
+          }
         }
       );
       this.activeTurns.set(threadId, handle);
       this.startingTurns.delete(threadId);
+      if (typeof handle.pid === "number" && handle.pid > 0) {
+        updateThread(threadId, { agentPid: handle.pid });
+      }
       if (this.stoppedTurns.has(threadId)) {
         handle.kill();
       } else {
@@ -3708,20 +3765,41 @@ var Orchestrator = class {
       if (result.sessionId) {
         updateThread(threadId, { sessionId: result.sessionId });
       }
-      const assistantText = result.assistantText.trim();
-      const failureOnlyMessage = result.exitCode !== 0 && looksLikeAgentFailureMessage(assistantText) && !result.parts.some((p) => p.type === "tool" || p.type === "thinking");
-      if (!failureOnlyMessage && (assistantText || result.parts.length > 0)) {
+      let assistantText = result.assistantText.trim();
+      let parts = result.parts;
+      let usage = result.usage ?? void 0;
+      let exitCode = result.exitCode;
+      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-L5PNQUDT.js");
+          for (let i = 0; i < 8; i++) {
+            const recovered = recoverFinishedCursorRun({
+              agentId: sessionId,
+              startedAfterMs: turnStartedAt - 5e3
+            });
+            if (recovered?.result) {
+              assistantText = recovered.result;
+              exitCode = 0;
+              break;
+            }
+            await new Promise((r) => setTimeout(r, 500));
+          }
+        }
+      }
+      const failureOnlyMessage = exitCode !== 0 && looksLikeAgentFailureMessage(assistantText) && !parts.some((p) => p.type === "tool" || p.type === "thinking");
+      if (!failureOnlyMessage && (assistantText || parts.length > 0)) {
         appendMessage(threadId, {
           role: "agent",
           text: assistantText,
-          parts: result.parts.length > 0 ? result.parts : void 0,
+          parts: parts.length > 0 ? parts : void 0,
           durationMs: Math.max(0, Date.now() - turnStartedAt),
-          usage: result.usage ?? void 0,
+          usage,
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
       const afterTurn = this.requireThread(threadId);
-      if (afterTurn.planMode && afterTurn.agent === "claude" && result.parts.some(
+      if (afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
         (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
       )) {
         updateThread(threadId, { sessionId: null });
@@ -3730,22 +3808,22 @@ var Orchestrator = class {
       if (this.stoppedTurns.has(threadId)) {
         setStatus(threadId, "stopped");
         this.emit({ type: "status_changed", threadId, status: "stopped" });
-        this.emit({ type: "turn_finished", threadId, exitCode: result.exitCode });
+        this.emit({ type: "turn_finished", threadId, exitCode });
       } else {
         const lastStderr = summarizeTurnStderr(stderrTail);
-        const detail = lastStderr || (result.exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
-        const failDetail = formatTurnExitError(result.exitCode, detail);
+        const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+        const failDetail = formatTurnExitError(exitCode, detail);
         setStatus(
           threadId,
-          result.exitCode === 0 ? "idle" : "error",
-          result.exitCode === 0 ? null : failDetail
+          exitCode === 0 ? "idle" : "error",
+          exitCode === 0 ? null : failDetail
         );
         this.emit({
           type: "status_changed",
           threadId,
-          status: result.exitCode === 0 ? "idle" : "error"
+          status: exitCode === 0 ? "idle" : "error"
         });
-        this.emit({ type: "turn_finished", threadId, exitCode: result.exitCode });
+        this.emit({ type: "turn_finished", threadId, exitCode });
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -3766,6 +3844,10 @@ var Orchestrator = class {
       this.processes.delete(`${threadId}:agent`);
       this.stoppedTurns.delete(threadId);
       this.runningCount = Math.max(0, this.runningCount - 1);
+      try {
+        updateThread(threadId, { agentPid: null });
+      } catch {
+      }
     }
   }
   /**
@@ -4339,7 +4421,7 @@ var Orchestrator = class {
       return setStatus(thread.id, "idle");
     }
     if (!existsSync11(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-37FBII5A.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-M3DTPYBW.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
@@ -4422,7 +4504,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-37FBII5A.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-M3DTPYBW.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return createThread({
@@ -4432,7 +4514,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-UNPZNIFW.js");
+  const { updateThread: upd } = await import("./thread-store-WPLT3IXM.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -5115,6 +5197,7 @@ export {
   worktreeCleanupSettings,
   applyThreadIntoMain,
   cloneRepoIntoSideboard,
+  isPidAlive,
   Orchestrator,
   getOrchestrator,
   startOrchestration,

package/dist/{chunk-BEXVE7LX.js → chunk-SX2R2PCE.js}

@@ -798,7 +798,7 @@ var claudeAdapter = {
       );
     }
     const mode = permissionMode(thread);
-    const { isOrchestratorThread } = await import("./global-workspace-QSRP25HQ.js");
+    const { isOrchestratorThread } = await import("./global-workspace-4GVWSCEX.js");
     const isOrchestrator = isOrchestratorThread(thread);
     const injectedServers = await buildInjectedMcpServers({
       includeSideboard: true,

package/dist/{chunk-PTASB7SJ.js → chunk-UPMGXM4X.js}

@@ -1,6 +1,6 @@
 import {
   resolveGithubRepoSlug
-} from "./chunk-XBEQI5H4.js";
+} from "./chunk-VA2U5EQH.js";
 import {
   globalAgentCwd,
   sideboardReposDir

package/dist/{chunk-XBEQI5H4.js → chunk-VA2U5EQH.js}

@@ -1,6 +1,6 @@
 import {
   listThreads
-} from "./chunk-HYRHI3QU.js";
+} from "./chunk-5UIKSPDD.js";
 import {
   worktreesRoot
 } from "./chunk-M37RITA6.js";

package/dist/{coordinator-prompt-WIYQVMOG.js → coordinator-prompt-FAILHO4J.js}

@@ -6,9 +6,9 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-PTASB7SJ.js";
-import "./chunk-XBEQI5H4.js";
-import "./chunk-HYRHI3QU.js";
+} from "./chunk-UPMGXM4X.js";
+import "./chunk-VA2U5EQH.js";
+import "./chunk-5UIKSPDD.js";
 import "./chunk-M37RITA6.js";
 import "./chunk-AJ6ROGD7.js";
 export {

package/dist/cursor-recover-L5PNQUDT.js

@@ -0,0 +1,42 @@
+import {
+  appDataDir
+} from "./chunk-M37RITA6.js";
+
+// src/agents/cursor-recover.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function recoverFinishedCursorRun(opts) {
+  const agentId = opts.agentId.trim();
+  if (!agentId) return null;
+  const runsPath = join(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!existsSync(runsPath)) return null;
+  try {
+    const lines = readFileSync(runsPath, "utf8").split("\n");
+    let best = null;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let row;
+      try {
+        row = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (row.agentId !== agentId) continue;
+      if (row.status !== "finished") continue;
+      if (typeof row.result !== "string" || !row.result.trim()) continue;
+      const endedAt = typeof row.endedAt === "number" ? row.endedAt : 0;
+      const createdAt = typeof row.createdAt === "number" ? row.createdAt : 0;
+      if (createdAt < opts.startedAfterMs && endedAt < opts.startedAfterMs) continue;
+      if (!best || endedAt >= best.endedAt) {
+        best = { runId: row.runId || "", result: row.result.trim(), endedAt };
+      }
+    }
+    return best;
+  } catch {
+    return null;
+  }
+}
+export {
+  recoverFinishedCursorRun
+};

package/dist/{global-workspace-QSRP25HQ.js → global-workspace-4GVWSCEX.js}

@@ -11,10 +11,10 @@ import {
   orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins,
   takenTeamSlugsForOrchestration
-} from "./chunk-IS3AGU33.js";
-import "./chunk-PTASB7SJ.js";
-import "./chunk-XBEQI5H4.js";
-import "./chunk-HYRHI3QU.js";
+} from "./chunk-6TZSJMXF.js";
+import "./chunk-UPMGXM4X.js";
+import "./chunk-VA2U5EQH.js";
+import "./chunk-5UIKSPDD.js";
 import {
   globalAgentCwd
 } from "./chunk-M37RITA6.js";