@sideboard-ai/core 0.1.193 → 0.1.195

package/dist/{chunk-O4BMPY5Y.js → chunk-E37JHCO3.js}

@@ -6,7 +6,7 @@ import {
   getAbleTimeHost,
   isAbleTimeConnected,
   saveAbleTimeConnection
-} from "./chunk-BWRS6GAS.js";
+} from "./chunk-S5GLSRLP.js";
 
 // src/integrations/abletime-mcp.ts
 var DEFAULT_ABLETIME_HOST = "https://track.abletime.com";

package/dist/{chunk-JTWKGOFI.js → chunk-FJZWM2ON.js}

@@ -8,7 +8,7 @@ function sanitizeGitBranchPrefix(raw) {
   return slug || null;
 }
 function resolveGitBranchPrefix(opts) {
-  return sanitizeGitBranchPrefix(opts.setting) ?? sanitizeGitBranchPrefix(opts.githubLogin);
+  return sanitizeGitBranchPrefix(opts.setting);
 }
 function examplePrefixedBranch(prefix, ticket) {
   const head = sanitizeGitBranchPrefix(prefix);

package/dist/{chunk-3DX2T2KR.js → chunk-GFH3QVAV.js}

@@ -1,10 +1,5 @@
 #!/usr/bin/env node
 
-import {
-  extractPresentedPlan,
-  readPlanFile,
-  writePlanFile
-} from "./chunk-JFOPOMK7.js";
 import {
   releaseCaffeinateHoldForThread
 } from "./chunk-YWI3IBP2.js";
@@ -41,7 +36,7 @@ import {
   summarizeTurnStderr,
   toolDescription,
   turnFailChatText
-} from "./chunk-EBPBGQ4P.js";
+} from "./chunk-6H2XPPPR.js";
 import {
   SLACK_REPLY_FORMATTING,
   addWorkspace,
@@ -64,9 +59,15 @@ import {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads
-} from "./chunk-HIX2VDRE.js";
+} from "./chunk-6YTI2HBG.js";
+import {
+  extractPresentedPlan,
+  readPlanFile,
+  writePlanFile
+} from "./chunk-JFOPOMK7.js";
 import {
   addPrStackLayer,
+  allocateTeamName,
   allocateTeamSlug,
   canonicalizeRepoPath,
   commitAll,
@@ -89,11 +90,13 @@ import {
   getPrStack,
   initPrStack,
   isDirty,
+  isPlaceholderBranch,
   isSideboardScratchPath,
   listWorktrees,
   markPrReady,
   mergeAgentGitAuthEnv,
   mergePr,
+  normalizeWorktreePath,
   originGhRepoEnv,
   pushBranch,
   removeWorktree,
@@ -104,8 +107,14 @@ import {
   resolvePrSelector,
   resolvePrSelectors,
   resolveRepoRoot,
-  withRepoGitLock
-} from "./chunk-XPKKCFRT.js";
+  takenSlugsFromThread,
+  threadDisplayLabel,
+  ticketSlugForBranch,
+  withRepoGitLock,
+  worktreeDisplayLabelForGroup,
+  worktreeNameFromPath,
+  worktreeSlugForTicket
+} from "./chunk-DP4TKAMZ.js";
 import {
   ATTACHMENTS_DIR,
   DETACHED_JOBS_DIR,
@@ -124,17 +133,6 @@ import {
   withThreadLock,
   writeThread
 } from "./chunk-CJFBSQIB.js";
-import {
-  allocateTeamName,
-  isPlaceholderBranch,
-  normalizeWorktreePath,
-  takenSlugsFromThread,
-  threadDisplayLabel,
-  ticketSlugForBranch,
-  worktreeDisplayLabelForGroup,
-  worktreeNameFromPath,
-  worktreeSlugForTicket
-} from "./chunk-64QSHOKV.js";
 import {
   ensureWorktreeSideboardIgnored
 } from "./chunk-SYFVUF2C.js";
@@ -170,7 +168,7 @@ import {
   stripNestedElectronEnv,
   updateAdvancedSettings,
   writeSecureJson
-} from "./chunk-KORE4WOF.js";
+} from "./chunk-AH6WIBLY.js";
 import {
   writePrivateFile
 } from "./chunk-NSTQ6QKD.js";
@@ -190,7 +188,7 @@ import {
 import {
   examplePrefixedBranch,
   sanitizeGitBranchPrefix
-} from "./chunk-JTWKGOFI.js";
+} from "./chunk-FJZWM2ON.js";
 
 // src/orchestrator/orchestrator.ts
 import { EventEmitter } from "events";
@@ -408,7 +406,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-SFOT6Q6F.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-EHRFN3Q6.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -801,9 +799,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-BZ6V6TEX.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-SNJ2Z6SL.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-GXJIPWNA.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-LYKS3YNG.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1446,6 +1444,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);
@@ -1542,7 +1587,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;
@@ -2187,6 +2233,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 = {
@@ -2200,6 +2247,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 };
 }
@@ -3530,7 +3581,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   if (input.cowboy) {
-    const { cowboyModeEnabled } = await import("./app-settings-QYLNKRK4.js");
+    const { cowboyModeEnabled } = await import("./app-settings-J775CYOO.js");
     if (!cowboyModeEnabled()) {
       throw new Error(
         "Cowboy mode is off. Enable it in Settings \u2192 Advanced."
@@ -3588,7 +3639,7 @@ async function createThread(input, _onSetupLine) {
   let sourceIsFork = false;
   if (!input.cowboy && sourceType === "branch" && (!sourceRef || sourceRef === "HEAD" || sourceRef === "default")) {
     if (isAbleTimeConnected() && getIssueSource() === "abletime") {
-      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-UX53JTIH.js");
+      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-HR6P4GJH.js");
       const task = await ensureAbleTimeTask({
         title: title?.trim() || "Untitled work",
         description: input.prompt?.trim() || void 0
@@ -4100,7 +4151,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ACMZMKPD.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-UTOYGBYB.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-N5X5I422.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
@@ -6478,7 +6529,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-SFOT6Q6F.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-EHRFN3Q6.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6753,7 +6804,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("./app-settings-QYLNKRK4.js");
+      const { autoCleanupOrphansEnabled } = await import("./app-settings-J775CYOO.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -7032,7 +7083,7 @@ var Orchestrator = class {
     }
     await setup;
     if (skipSetup) return;
-    const { autoRunAfterSetupEnabled } = await import("./app-settings-QYLNKRK4.js");
+    const { autoRunAfterSetupEnabled } = await import("./app-settings-J775CYOO.js");
     if (autoRunAfterSetupEnabled()) {
       try {
         await this.startDev(threadId);
@@ -7355,7 +7406,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled, getGithubGitAuthMode, gitBranchPrefixSetting } = await import("./app-settings-QYLNKRK4.js");
+    const { autoRenameBranchEnabled, getGithubGitAuthMode, gitBranchPrefixSetting } = await import("./app-settings-J775CYOO.js");
     const gitAuthMode = getGithubGitAuthMode();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -7393,21 +7444,11 @@ var Orchestrator = class {
     const settings = loadWorkspaceSettings(fresh.worktreePath, fresh.repoPath);
     let renameBranchDirective = null;
     if (!isBrightsy && !isOrchestration && autoRenameBranchEnabled()) {
-      const { isPlaceholderBranch: isPlaceholderBranch2 } = await import("./worktree-labels-PEDOJBMD.js");
-      let githubLogin = null;
-      if (isPlaceholderBranch2(fresh.branchName, fresh.worktreePath) && !gitBranchPrefixSetting()) {
-        try {
-          const { getGitHubStatus } = await import("./github-DWROJOB7.js");
-          githubLogin = (await getGitHubStatus()).login;
-        } catch {
-        }
-      }
-      const { resolveGitBranchPrefix } = await import("./branch-prefix-EVW2KHGQ.js");
+      const { resolveGitBranchPrefix } = await import("./branch-prefix-7DTIUJT2.js");
       renameBranchDirective = formatRenameBranchDirective(fresh, {
         customPrompt: settings?.prompts?.renameBranch,
         branchPrefix: resolveGitBranchPrefix({
-          setting: gitBranchPrefixSetting(),
-          githubLogin
+          setting: gitBranchPrefixSetting()
         })
       });
     }
@@ -7770,22 +7811,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(
@@ -7820,7 +7864,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,
@@ -7835,13 +7879,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,
@@ -7850,15 +7895,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,
@@ -7869,51 +7913,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, {
@@ -7921,13 +7996,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 {
@@ -7935,14 +8014,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);
@@ -7970,8 +8057,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);
@@ -8298,7 +8391,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("./app-settings-QYLNKRK4.js");
+    const { autoArchiveOnMergeEnabled } = await import("./app-settings-J775CYOO.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -8590,7 +8683,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ACMZMKPD.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-UTOYGBYB.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -8617,7 +8710,7 @@ var Orchestrator = class {
           await runArchiveScript(thread.repoPath, thread.worktreePath);
         } catch {
         }
-        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-QYLNKRK4.js");
+        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-J775CYOO.js");
         const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
         await removeWorktree(thread.repoPath, thread.worktreePath, {
           deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -8644,7 +8737,7 @@ var Orchestrator = class {
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-6IEVF3GN.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-R43JOR4V.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -8754,7 +8847,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-6IEVF3GN.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-R43JOR4V.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({