@sideboard-ai/core 0.1.193 → 0.1.195

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

@@ -1,3 +1,8 @@
+import {
+  extractPresentedPlan,
+  readPlanFile,
+  writePlanFile
+} from "./chunk-DJU54RYW.js";
 import {
   PLAN_MODE_INSTRUCTION,
   allAdapters,
@@ -19,12 +24,7 @@ import {
   stripBrightsyNdjsonNoise,
   sumUsageList,
   toolDescription
-} from "./chunk-MQC2VA5U.js";
-import {
-  extractPresentedPlan,
-  readPlanFile,
-  writePlanFile
-} from "./chunk-DJU54RYW.js";
+} from "./chunk-2X6RGKLI.js";
 import {
   SLACK_REPLY_FORMATTING,
   addWorkspace,
@@ -47,9 +47,10 @@ import {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads
-} from "./chunk-4OVCJPVI.js";
+} from "./chunk-HZTHWU6A.js";
 import {
   addPrStackLayer,
+  allocateTeamName,
   allocateTeamSlug,
   canonicalizeRepoPath,
   commitAll,
@@ -72,11 +73,13 @@ import {
   getPrStack,
   initPrStack,
   isDirty,
+  isPlaceholderBranch,
   isSideboardScratchPath,
   listWorktrees,
   markPrReady,
   mergeAgentGitAuthEnv,
   mergePr,
+  normalizeWorktreePath,
   originGhRepoEnv,
   pushBranch,
   removeWorktree,
@@ -87,8 +90,14 @@ import {
   resolvePrSelector,
   resolvePrSelectors,
   resolveRepoRoot,
-  withRepoGitLock
-} from "./chunk-BIKCWYRP.js";
+  takenSlugsFromThread,
+  threadDisplayLabel,
+  ticketSlugForBranch,
+  withRepoGitLock,
+  worktreeDisplayLabelForGroup,
+  worktreeNameFromPath,
+  worktreeSlugForTicket
+} from "./chunk-S4QCBBXS.js";
 import {
   ATTACHMENTS_DIR,
   DETACHED_JOBS_DIR,
@@ -118,15 +127,7 @@ import {
   shouldRetryFailedAgentTurn,
   summarizeTurnStderr,
   turnFailChatText
-} from "./chunk-7AJ7OZZF.js";
-import {
-  clearStaleIndexLocks,
-  enrichPathWithNpmGlobalBin,
-  ensureAgentPath,
-  git,
-  resolveGitDirsForLockRecovery,
-  run
-} from "./chunk-UFHNSFAS.js";
+} from "./chunk-NLHFAMC2.js";
 import {
   assertOrchestratorCapableAgent,
   childEnvWithAppSettings,
@@ -151,14 +152,14 @@ import {
   saveAppSettings,
   updateAdvancedSettings,
   writeSecureJson
-} from "./chunk-BWRS6GAS.js";
+} from "./chunk-S5GLSRLP.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-4TR3HZFT.js";
 import {
   examplePrefixedBranch,
   sanitizeGitBranchPrefix
-} from "./chunk-7SNJMKD6.js";
+} from "./chunk-WDRMZKVB.js";
 import {
   releaseCaffeinateHoldForThread
 } from "./chunk-4TYXWPAJ.js";
@@ -191,16 +192,13 @@ import {
   worktreesRoot
 } from "./chunk-WFUDY6PC.js";
 import {
-  allocateTeamName,
-  isPlaceholderBranch,
-  normalizeWorktreePath,
-  takenSlugsFromThread,
-  threadDisplayLabel,
-  ticketSlugForBranch,
-  worktreeDisplayLabelForGroup,
-  worktreeNameFromPath,
-  worktreeSlugForTicket
-} from "./chunk-RCWHL4TK.js";
+  clearStaleIndexLocks,
+  enrichPathWithNpmGlobalBin,
+  ensureAgentPath,
+  git,
+  resolveGitDirsForLockRecovery,
+  run
+} from "./chunk-UFHNSFAS.js";
 
 // src/orchestrator/orchestrator.ts
 import { EventEmitter } from "events";
@@ -473,7 +471,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-4KI6VIFG.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-6ESBGMDN.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -807,9 +805,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-MMK5UFUZ.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-4QX6UEOY.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-WB65HIZ3.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-IX66YUJ2.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1477,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);
@@ -1573,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;
@@ -2246,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 = {
@@ -2259,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 };
 }
@@ -3659,7 +3710,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   if (input.cowboy) {
-    const { cowboyModeEnabled } = await import("./app-settings-LO7UFHQ6.js");
+    const { cowboyModeEnabled } = await import("./app-settings-5KHVKJKO.js");
     if (!cowboyModeEnabled()) {
       throw new Error(
         "Cowboy mode is off. Enable it in Settings \u2192 Advanced."
@@ -3717,7 +3768,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-QHKWGTBY.js");
+      const { ensureAbleTimeTask, issueAttachmentForAbleTimeTask } = await import("./abletime-JINF5KJV.js");
       const task = await ensureAbleTimeTask({
         title: title?.trim() || "Untitled work",
         description: input.prompt?.trim() || void 0
@@ -3819,7 +3870,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-MN4GSQTL.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-OXDDPH2O.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -4241,7 +4292,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-KPJS7GLY.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-URMUVGAQ.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-X54WSOXM.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
@@ -6825,7 +6876,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-4KI6VIFG.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-6ESBGMDN.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -7100,7 +7151,7 @@ var Orchestrator = class {
           orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
         });
       }
-      const { autoCleanupOrphansEnabled } = await import("./app-settings-LO7UFHQ6.js");
+      const { autoCleanupOrphansEnabled } = await import("./app-settings-5KHVKJKO.js");
       if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
         await cleanupOrphanWorktrees({ repoPaths });
       }
@@ -7379,7 +7430,7 @@ var Orchestrator = class {
     }
     await setup;
     if (skipSetup) return;
-    const { autoRunAfterSetupEnabled } = await import("./app-settings-LO7UFHQ6.js");
+    const { autoRunAfterSetupEnabled } = await import("./app-settings-5KHVKJKO.js");
     if (autoRunAfterSetupEnabled()) {
       try {
         await this.startDev(threadId);
@@ -7702,7 +7753,7 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const { autoRenameBranchEnabled, getGithubGitAuthMode, gitBranchPrefixSetting } = await import("./app-settings-LO7UFHQ6.js");
+    const { autoRenameBranchEnabled, getGithubGitAuthMode, gitBranchPrefixSetting } = await import("./app-settings-5KHVKJKO.js");
     const gitAuthMode = getGithubGitAuthMode();
     const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
       githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
@@ -7740,21 +7791,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-3XDS6O3U.js");
-      let githubLogin = null;
-      if (isPlaceholderBranch2(fresh.branchName, fresh.worktreePath) && !gitBranchPrefixSetting()) {
-        try {
-          const { getGitHubStatus } = await import("./github-IIF7AQNO.js");
-          githubLogin = (await getGitHubStatus()).login;
-        } catch {
-        }
-      }
-      const { resolveGitBranchPrefix } = await import("./branch-prefix-7F37FIPX.js");
+      const { resolveGitBranchPrefix } = await import("./branch-prefix-N3KTCRCE.js");
       renameBranchDirective = formatRenameBranchDirective(fresh, {
         customPrompt: settings?.prompts?.renameBranch,
         branchPrefix: resolveGitBranchPrefix({
-          setting: gitBranchPrefixSetting(),
-          githubLogin
+          setting: gitBranchPrefixSetting()
         })
       });
     }
@@ -8117,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(
@@ -8167,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,
@@ -8182,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,
@@ -8197,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,
@@ -8216,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, {
@@ -8268,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 {
@@ -8282,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);
@@ -8317,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);
@@ -8645,7 +8738,7 @@ var Orchestrator = class {
         updateThread(thread.id, { title: meta.title });
       }
     }
-    const { autoArchiveOnMergeEnabled } = await import("./app-settings-LO7UFHQ6.js");
+    const { autoArchiveOnMergeEnabled } = await import("./app-settings-5KHVKJKO.js");
     const latest = this.requireThread(thread.id);
     if (!shouldAutoArchiveOnPrMerge({
       previousPrState: prevState || null,
@@ -8937,7 +9030,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-KPJS7GLY.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-URMUVGAQ.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -8964,7 +9057,7 @@ var Orchestrator = class {
           await runArchiveScript(thread.repoPath, thread.worktreePath);
         } catch {
         }
-        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-LO7UFHQ6.js");
+        const { deleteBranchOnPurgeEnabled } = await import("./app-settings-5KHVKJKO.js");
         const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
         await removeWorktree(thread.repoPath, thread.worktreePath, {
           deleteBranch: deleteBranch ? thread.branchName : void 0
@@ -8991,7 +9084,7 @@ var Orchestrator = class {
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-UW6DNBIE.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-RM6UWNGZ.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -9101,7 +9194,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-UW6DNBIE.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-RM6UWNGZ.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({

package/dist/{chunk-4OVCJPVI.js → chunk-HZTHWU6A.js}

@@ -1,8 +1,11 @@
 import {
+  allocateTeamName,
   ensureGhPreferOrigin,
   resolveGithubRepoSlug,
-  resolveRepoRoot
-} from "./chunk-BIKCWYRP.js";
+  resolveRepoRoot,
+  takenSlugsFromThread,
+  teamSlugFromName
+} from "./chunk-S4QCBBXS.js";
 import {
   ATTACHMENTS_DIR,
   attachmentsGitignoreBody
@@ -19,7 +22,7 @@ import {
   resolveThreadDefaults,
   resolveViewerProfile,
   resolveViewerProfileForRepo
-} from "./chunk-BWRS6GAS.js";
+} from "./chunk-S5GLSRLP.js";
 import {
   createEmptyThread,
   listThreads,
@@ -31,11 +34,6 @@ import {
   globalAgentCwd,
   sideboardReposDir
 } from "./chunk-WFUDY6PC.js";
-import {
-  allocateTeamName,
-  takenSlugsFromThread,
-  teamSlugFromName
-} from "./chunk-RCWHL4TK.js";
 
 // src/store/workspaces.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";

package/dist/{chunk-4QJRH5DL.js → chunk-KTHRWHA3.js}

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