@sideboard-ai/core 0.1.194 → 0.1.195

package/dist/index.d.cts

@@ -4489,9 +4489,12 @@ declare class Orchestrator {
         ports: number[];
     }>;
     stopDev(threadRef: string, scriptName?: string): void;
+    private syncWorktreeRuns;
     listThreadRunScripts(threadRef: string): RunScript[];
     getActiveRuns(threadRef: string): ActiveRun[];
     getSetupLog(threadRef: string): SetupLogSnapshot;
+    private hasWorktreeSetupProcess;
+    private writeSetupLog;
     runSetup(threadRef: string, opts?: {
         stampLastError?: boolean;
     }): Promise<{

package/dist/index.d.ts

@@ -4489,9 +4489,12 @@ declare class Orchestrator {
         ports: number[];
     }>;
     stopDev(threadRef: string, scriptName?: string): void;
+    private syncWorktreeRuns;
     listThreadRunScripts(threadRef: string): RunScript[];
     getActiveRuns(threadRef: string): ActiveRun[];
     getSetupLog(threadRef: string): SetupLogSnapshot;
+    private hasWorktreeSetupProcess;
+    private writeSetupLog;
     runSetup(threadRef: string, opts?: {
         stampLastError?: boolean;
     }): Promise<{

package/dist/index.js

@@ -268,7 +268,7 @@ import {
   worktreeCleanupSettings,
   wrapReviewSkillMarkdown,
   writeWorktreeFile
-} from "./chunk-NY366OEZ.js";
+} from "./chunk-HAVI6AY3.js";
 import {
   LEGACY_PLAN_FILE_REL,
   PLAN_FILE_NAME,

package/dist/mcp/run-stdio.cjs

@@ -13022,6 +13022,59 @@ var init_context_compact = __esm({
   }
 });
 
+// src/threads/worktree-runtime.ts
+function worktreeProcessPrefix(worktreePath) {
+  return `wt:${normalizeWorktreePath(worktreePath)}`;
+}
+function worktreeSetupProcessKey(worktreePath) {
+  return `${worktreeProcessPrefix(worktreePath)}:setup`;
+}
+function worktreeRunProcessKey(worktreePath, scriptName) {
+  return `${worktreeProcessPrefix(worktreePath)}:run:${scriptName}`;
+}
+function worktreeDevProcessKey(worktreePath) {
+  return `${worktreeProcessPrefix(worktreePath)}:dev`;
+}
+function isWorktreeRunProcessKey(key, worktreePath) {
+  const prefix = worktreeProcessPrefix(worktreePath);
+  return key.startsWith(`${prefix}:run:`) || key === `${prefix}:dev`;
+}
+function pickRichestSetupLog(snaps) {
+  let best;
+  for (const snap of snaps) {
+    if (!snap.output && !snap.running && snap.exitCode == null) continue;
+    if (!best) {
+      best = snap;
+      continue;
+    }
+    if (snap.running && !best.running) {
+      best = snap;
+      continue;
+    }
+    if (snap.running === best.running && snap.output.length > best.output.length) {
+      best = snap;
+    }
+  }
+  return best;
+}
+function mergeWorktreeActiveRuns(threads) {
+  const byName = /* @__PURE__ */ new Map();
+  let devPort = null;
+  for (const thread of threads) {
+    if (thread.devPort != null && devPort == null) devPort = thread.devPort;
+    for (const run2 of thread.activeRuns ?? []) {
+      if (!byName.has(run2.scriptName)) byName.set(run2.scriptName, run2);
+    }
+  }
+  return { activeRuns: [...byName.values()], devPort };
+}
+var init_worktree_runtime = __esm({
+  "src/threads/worktree-runtime.ts"() {
+    "use strict";
+    init_worktree_labels();
+  }
+});
+
 // src/threads/chat-tabs.ts
 function sameWorktreePath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
@@ -13118,7 +13171,8 @@ function createChatTab(input) {
     planMode: from.planMode,
     autonomy: input.autonomy ?? from.autonomy,
     attachments: input.attachments ?? [],
-    status: "idle"
+    status: "idle",
+    ...mergeWorktreeActiveRuns(threadsSharingWorktree(binding.worktreePath))
   });
   writeThread(thread);
   return thread;
@@ -13152,6 +13206,7 @@ var init_chat_tabs = __esm({
     init_global_workspace();
     init_orchestrator_capable();
     init_thread_store();
+    init_worktree_runtime();
     init_worktree_labels();
   }
 });
@@ -13820,6 +13875,10 @@ var init_conductor = __esm({
 function setupLogPath(threadId) {
   return (0, import_node_path36.join)(threadsDir(), `${threadId}.setup.log.json`);
 }
+function setupLogKeyForWorktree(worktreePath) {
+  const norm = normalizeWorktreePath(worktreePath);
+  return `wt-${(0, import_node_crypto8.createHash)("sha1").update(norm).digest("hex").slice(0, 16)}`;
+}
 function emptySetupLog() {
   return { ...EMPTY };
 }
@@ -13910,12 +13969,14 @@ function finishSetupLog(threadId, exitCode, source) {
   persistNow(threadId);
   return clone(snap);
 }
-var import_node_fs36, import_node_path36, EMPTY, memory, persistTimers;
+var import_node_crypto8, import_node_fs36, import_node_path36, EMPTY, memory, persistTimers;
 var init_setup_log = __esm({
   "src/store/setup-log.ts"() {
     "use strict";
+    import_node_crypto8 = require("crypto");
     import_node_fs36 = require("fs");
     import_node_path36 = require("path");
+    init_worktree_labels();
     init_paths();
     EMPTY = {
       output: "",
@@ -16384,7 +16445,7 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
     `- Do not wait on the limited ${from.agent} account; keep going on ${fallbackAgent}.`
   ].join("\n");
   return {
-    id: (0, import_node_crypto8.randomUUID)(),
+    id: (0, import_node_crypto9.randomUUID)(),
     name: "Orchestration quota handoff.md",
     kind: "transcript",
     content: body
@@ -16405,11 +16466,11 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
     sourceType: "orchestration"
   });
 }
-var import_node_crypto8, QUOTA_CONTINUE_PROMPT, QUOTA_RESUME_PROMPT;
+var import_node_crypto9, QUOTA_CONTINUE_PROMPT, QUOTA_RESUME_PROMPT;
 var init_quota_failover = __esm({
   "src/orchestrator/quota-failover.ts"() {
     "use strict";
-    import_node_crypto8 = require("crypto");
+    import_node_crypto9 = require("crypto");
     init_session_quota();
     init_app_settings();
     init_global_workspace();
@@ -19167,7 +19228,7 @@ function buildTask(input, now) {
   const ts = nowIso2(now);
   const agent = input.agent ? coerceOrchestratorAgent(input.agent) : null;
   return {
-    id: (0, import_node_crypto9.randomUUID)(),
+    id: (0, import_node_crypto10.randomUUID)(),
     name: input.name?.trim() || defaultScheduleName(prompt),
     prompt,
     enabled: input.enabled !== false,
@@ -19254,11 +19315,11 @@ function recordScheduleRun(id, result) {
   writeAll2(rows);
   return next;
 }
-var import_node_crypto9, import_node_fs51, import_node_path48, import_croner, DURATION_RE, UNIT_MS;
+var import_node_crypto10, import_node_fs51, import_node_path48, import_croner, DURATION_RE, UNIT_MS;
 var init_schedules = __esm({
   "src/store/schedules.ts"() {
     "use strict";
-    import_node_crypto9 = require("crypto");
+    import_node_crypto10 = require("crypto");
     import_node_fs51 = require("fs");
     import_node_path48 = require("path");
     import_croner = require("croner");
@@ -19666,6 +19727,7 @@ var init_orchestrator = __esm({
     init_setup_last_error();
     init_request_review();
     init_fork_worktree();
+    init_worktree_runtime();
     init_quota_failover();
     init_adopt();
     init_stack_layers();
@@ -20831,22 +20893,25 @@ var init_orchestrator = __esm({
             "No run script found for this worktree. Add [scripts.run.*] in the worktree\u2019s .sideboard/settings.toml or .conductor/settings.toml (or settings.local.toml on the main repo)."
           );
         }
-        const runKey = `${thread.id}:run:${resolvedName}`;
-        const existing = this.processes.get(runKey);
-        const active = (thread.activeRuns ?? []).find((r) => r.scriptName === resolvedName);
+        const siblings = threadsSharingWorktree(thread.worktreePath);
+        const shared = mergeWorktreeActiveRuns(siblings);
+        const runKey = worktreeRunProcessKey(thread.worktreePath, resolvedName);
+        const existing = this.processes.get(runKey) ?? siblings.map((t) => this.processes.get(`${t.id}:run:${resolvedName}`)).find(Boolean);
+        const active = shared.activeRuns.find((r) => r.scriptName === resolvedName);
         if (existing && active) {
           return { port: active.port, scriptName: resolvedName, ports: active.ports };
         }
         if (!scriptName) {
-          const legacy = this.processes.get(`${thread.id}:dev`);
-          if (legacy && thread.devPort) {
-            return { port: thread.devPort, scriptName: resolvedName, ports: [thread.devPort] };
+          const legacy = this.processes.get(worktreeDevProcessKey(thread.worktreePath)) ?? siblings.map((t) => this.processes.get(`${t.id}:dev`)).find(Boolean);
+          if (legacy && shared.devPort) {
+            return { port: shared.devPort, scriptName: resolvedName, ports: [shared.devPort] };
           }
         }
         const mode = getRunMode(thread.worktreePath, thread.repoPath);
         if (mode === "nonconcurrent") {
+          const here = normalizeWorktreePath(thread.worktreePath);
           for (const t of listThreads()) {
-            if (t.id === thread.id) continue;
+            if (normalizeWorktreePath(t.worktreePath) === here) continue;
             const runs = t.activeRuns ?? [];
             if (runs.length > 0 || t.devPort) {
               throw new Error(
@@ -20881,7 +20946,7 @@ var init_orchestrator = __esm({
         });
         const isDefault = scripts.find((s) => s.default)?.name === resolvedName || !scripts.some((s) => s.default) && (resolvedName === "dev" || resolvedName === scripts[0]?.name);
         if (isDefault) {
-          this.processes.set(`${thread.id}:dev`, {
+          this.processes.set(worktreeDevProcessKey(thread.worktreePath), {
             kind: "dev",
             pid: handle.pid,
             startedAt,
@@ -20896,13 +20961,14 @@ var init_orchestrator = __esm({
           startedAt
         };
         const nextRuns = [
-          ...(thread.activeRuns ?? []).filter((r) => r.scriptName !== resolvedName),
+          ...shared.activeRuns.filter((r) => r.scriptName !== resolvedName),
           run2
         ];
-        updateThread(thread.id, {
-          activeRuns: nextRuns,
-          devPort: isDefault ? handle.port : thread.devPort
-        });
+        this.syncWorktreeRuns(
+          thread.worktreePath,
+          nextRuns,
+          isDefault ? handle.port : shared.devPort
+        );
         this.emit({
           type: "dev_server_started",
           threadId: thread.id,
@@ -20911,15 +20977,14 @@ var init_orchestrator = __esm({
         });
         void handle.done.then(() => {
           this.processes.delete(runKey);
-          if (isDefault) this.processes.delete(`${thread.id}:dev`);
-          const latest = readThread(thread.id);
-          const remaining = (latest?.activeRuns ?? []).filter(
-            (r) => r.scriptName !== resolvedName
+          if (isDefault) this.processes.delete(worktreeDevProcessKey(thread.worktreePath));
+          const latest = mergeWorktreeActiveRuns(threadsSharingWorktree(thread.worktreePath));
+          const remaining = latest.activeRuns.filter((r) => r.scriptName !== resolvedName);
+          this.syncWorktreeRuns(
+            thread.worktreePath,
+            remaining,
+            isDefault ? null : latest.devPort
           );
-          updateThread(thread.id, {
-            activeRuns: remaining,
-            devPort: isDefault ? null : latest?.devPort ?? null
-          });
           this.emit({
             type: "dev_server_stopped",
             threadId: thread.id,
@@ -20930,51 +20995,82 @@ var init_orchestrator = __esm({
       }
       stopDev(threadRef, scriptName) {
         const thread = this.requireThread(threadRef);
+        const siblings = threadsSharingWorktree(thread.worktreePath);
+        const shared = mergeWorktreeActiveRuns(siblings);
         if (scriptName) {
-          const runKey = `${thread.id}:run:${scriptName}`;
-          const proc = this.processes.get(runKey);
-          if (proc) proc.kill();
-          this.processes.delete(runKey);
-          const remaining = (thread.activeRuns ?? []).filter((r) => r.scriptName !== scriptName);
-          const isPrimary = thread.devPort != null && thread.activeRuns?.find((r) => r.scriptName === scriptName)?.port === thread.devPort;
-          updateThread(thread.id, {
-            activeRuns: remaining,
-            devPort: isPrimary ? null : thread.devPort
-          });
+          const keys = [
+            worktreeRunProcessKey(thread.worktreePath, scriptName),
+            ...siblings.map((t) => `${t.id}:run:${scriptName}`)
+          ];
+          for (const key of keys) {
+            const proc = this.processes.get(key);
+            if (proc) proc.kill();
+            this.processes.delete(key);
+          }
+          const remaining = shared.activeRuns.filter((r) => r.scriptName !== scriptName);
+          const isPrimary = shared.devPort != null && shared.activeRuns.find((r) => r.scriptName === scriptName)?.port === shared.devPort;
+          this.syncWorktreeRuns(
+            thread.worktreePath,
+            remaining,
+            isPrimary ? null : shared.devPort
+          );
           this.emit({ type: "dev_server_stopped", threadId: thread.id, scriptName });
           return;
         }
         for (const [key, proc] of [...this.processes.entries()]) {
-          if (key.startsWith(`${thread.id}:run:`) || key === `${thread.id}:dev`) {
+          if (isWorktreeRunProcessKey(key, thread.worktreePath) || siblings.some((t) => key.startsWith(`${t.id}:run:`) || key === `${t.id}:dev`)) {
             proc.kill();
             this.processes.delete(key);
           }
         }
-        updateThread(thread.id, { activeRuns: [], devPort: null });
+        this.syncWorktreeRuns(thread.worktreePath, [], null);
         this.emit({ type: "dev_server_stopped", threadId: thread.id });
       }
+      syncWorktreeRuns(worktreePath, activeRuns, devPort) {
+        for (const sibling of threadsSharingWorktree(worktreePath)) {
+          updateThread(sibling.id, { activeRuns, devPort });
+        }
+      }
       listThreadRunScripts(threadRef) {
         const thread = this.requireThread(threadRef);
         return listRunScripts(thread.worktreePath, thread.repoPath);
       }
       getActiveRuns(threadRef) {
-        return this.requireThread(threadRef).activeRuns ?? [];
+        const thread = this.requireThread(threadRef);
+        return mergeWorktreeActiveRuns(threadsSharingWorktree(thread.worktreePath)).activeRuns;
       }
       getSetupLog(threadRef) {
         const thread = this.getThread(threadRef);
         if (!thread) return readSetupLog(threadRef);
-        const snap = readSetupLog(thread.id);
-        if (snap.running && !this.processes.has(`${thread.id}:setup`)) {
+        const siblingIds = [
+          thread.id,
+          ...threadsSharingWorktree(thread.worktreePath).map((t) => t.id)
+        ];
+        const snap = pickRichestSetupLog([
+          readSetupLog(setupLogKeyForWorktree(thread.worktreePath)),
+          ...[...new Set(siblingIds)].map((id) => readSetupLog(id))
+        ]) ?? readSetupLog(thread.id);
+        if (snap.running && !this.hasWorktreeSetupProcess(thread.worktreePath)) {
           return { ...snap, running: false };
         }
         return snap;
       }
+      hasWorktreeSetupProcess(worktreePath) {
+        if (this.processes.has(worktreeSetupProcessKey(worktreePath))) return true;
+        return threadsSharingWorktree(worktreePath).some(
+          (t) => this.processes.has(`${t.id}:setup`)
+        );
+      }
+      writeSetupLog(threadId, worktreePath, fn) {
+        fn(setupLogKeyForWorktree(worktreePath));
+        fn(threadId);
+      }
       async runSetup(threadRef, opts) {
         const thread = this.requireThread(threadRef);
         this.assertNotGlobal(thread, "Setup");
-        const key = `${thread.id}:setup`;
-        if (this.processes.has(key)) {
-          throw new Error("Setup already running for this thread");
+        const key = worktreeSetupProcessKey(thread.worktreePath);
+        if (this.hasWorktreeSetupProcess(thread.worktreePath)) {
+          throw new Error("Setup already running for this worktree");
         }
         const abort = new AbortController();
         this.processes.set(key, {
@@ -20982,13 +21078,17 @@ var init_orchestrator = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           kill: () => abort.abort()
         });
-        beginSetupLog(thread.id);
+        this.writeSetupLog(thread.id, thread.worktreePath, beginSetupLog);
         this.emit({ type: "setup_started", threadId: thread.id });
         let finished = false;
         const finish = (exitCode, source) => {
           if (finished) return;
           finished = true;
-          finishSetupLog(thread.id, exitCode, source);
+          this.writeSetupLog(
+            thread.id,
+            thread.worktreePath,
+            (logKey) => finishSetupLog(logKey, exitCode, source)
+          );
           this.emit({ type: "setup_finished", threadId: thread.id, exitCode });
         };
         try {
@@ -20996,14 +21096,22 @@ var init_orchestrator = __esm({
             thread.repoPath,
             thread.worktreePath,
             (line) => {
-              appendSetupLog(thread.id, line);
+              this.writeSetupLog(
+                thread.id,
+                thread.worktreePath,
+                (logKey) => appendSetupLog(logKey, line)
+              );
               this.emit({ type: "setup_output", threadId: thread.id, line });
             },
             { signal: abort.signal }
           );
           if (!setup.ran) {
             const line = "No setup script in .sideboard/settings.toml, .conductor/settings.toml, .cursor/worktrees.json, or script/setup (bin/setup, scripts/setup)";
-            appendSetupLog(thread.id, line);
+            this.writeSetupLog(
+              thread.id,
+              thread.worktreePath,
+              (logKey) => appendSetupLog(logKey, line)
+            );
             this.emit({ type: "setup_output", threadId: thread.id, line });
             finish(null, null);
             throw new Error(line);
@@ -21031,8 +21139,14 @@ var init_orchestrator = __esm({
       }
       cancelSetup(threadRef) {
         const thread = this.requireThread(threadRef);
-        const proc = this.processes.get(`${thread.id}:setup`);
-        if (proc) proc.kill();
+        const keys = [
+          worktreeSetupProcessKey(thread.worktreePath),
+          ...threadsSharingWorktree(thread.worktreePath).map((t) => `${t.id}:setup`)
+        ];
+        for (const key of [...new Set(keys)]) {
+          const proc = this.processes.get(key);
+          if (proc) proc.kill();
+        }
       }
       async applyIntoMain(threadRef, opts) {
         const thread = this.requireThread(threadRef);
@@ -21782,7 +21896,7 @@ init_system_ca();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod9 = require("zod");
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_node_path52 = require("path");
 init_orchestrator();
 init_worktree();
@@ -22209,7 +22323,7 @@ async function createGitHubIssue(input, opts) {
 init_fetch();
 
 // src/integrations/linear-oauth.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var import_node_http = require("http");
 init_app_settings();
 init_fetch();
@@ -25192,7 +25306,7 @@ init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var import_node_fs54 = require("fs");
 var import_node_path50 = require("path");
 init_paths();
@@ -26041,7 +26155,7 @@ async function startMcpServer() {
           const ident = issue?.identifier ?? ref.trim();
           const attachments = issue ? [
             {
-              id: (0, import_node_crypto12.randomUUID)(),
+              id: (0, import_node_crypto13.randomUUID)(),
               name: issue.identifier,
               kind: "issue",
               content: [

package/dist/mcp/run-stdio.js

@@ -38,7 +38,7 @@ import {
   syncBoardPins,
   updateSchedule,
   waitForDetachedJob
-} from "../chunk-VRPPFKAO.js";
+} from "../chunk-GFH3QVAV.js";
 import "../chunk-YWI3IBP2.js";
 import {
   applySystemCaEnv,

package/dist/{orchestrator-S3M2E7O6.js → orchestrator-6ESBGMDN.js}

@@ -7,7 +7,7 @@ import {
   resolveSendFollowUp,
   startOrchestration,
   waitForPidExit
-} from "./chunk-NY366OEZ.js";
+} from "./chunk-HAVI6AY3.js";
 import "./chunk-DJU54RYW.js";
 import "./chunk-2X6RGKLI.js";
 import "./chunk-HZTHWU6A.js";

package/dist/{orchestrator-A5KF2335.js → orchestrator-EHRFN3Q6.js}

@@ -9,7 +9,7 @@ import {
   resolveSendFollowUp,
   startOrchestration,
   waitForPidExit
-} from "./chunk-VRPPFKAO.js";
+} from "./chunk-GFH3QVAV.js";
 import "./chunk-YWI3IBP2.js";
 import "./chunk-6H2XPPPR.js";
 import "./chunk-6YTI2HBG.js";

package/package.json

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