@sideboard-ai/core 0.1.194 → 0.1.195

package/dist/{chunk-NY366OEZ.js → chunk-HAVI6AY3.js}

@@ -471,7 +471,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-S3M2E7O6.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-6ESBGMDN.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -1475,6 +1475,53 @@ async function maybeCompactContext(thread, thresholds = {}, summarize = summariz
   };
 }
 
+// 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 };
+}
+
 // src/threads/chat-tabs.ts
 function sameWorktreePath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
@@ -1571,7 +1618,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;
@@ -2244,6 +2292,7 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
 }
 
 // src/store/setup-log.ts
+import { createHash } from "crypto";
 import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { join as join7 } from "path";
 var EMPTY = {
@@ -2257,6 +2306,10 @@ var persistTimers = /* @__PURE__ */ new Map();
 function setupLogPath(threadId) {
   return join7(threadsDir(), `${threadId}.setup.log.json`);
 }
+function setupLogKeyForWorktree(worktreePath) {
+  const norm = normalizeWorktreePath(worktreePath);
+  return `wt-${createHash("sha1").update(norm).digest("hex").slice(0, 16)}`;
+}
 function emptySetupLog() {
   return { ...EMPTY };
 }
@@ -6823,7 +6876,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-S3M2E7O6.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-6ESBGMDN.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -8105,22 +8158,25 @@ var Orchestrator = class {
         "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(
@@ -8155,7 +8211,7 @@ var Orchestrator = class {
     });
     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,
@@ -8170,13 +8226,14 @@ var Orchestrator = class {
       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,
@@ -8185,15 +8242,14 @@ var Orchestrator = class {
     });
     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,
@@ -8204,51 +8260,82 @@ var Orchestrator = class {
   }
   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, {
@@ -8256,13 +8343,17 @@ var Orchestrator = class {
       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 {
@@ -8270,14 +8361,22 @@ var Orchestrator = class {
         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);
@@ -8305,8 +8404,14 @@ var Orchestrator = class {
   }
   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);