@sideboard-ai/core 0.1.292 → 0.1.293

package/dist/agents/cursor-runner.js

@@ -35,9 +35,291 @@ import {
 import "../chunk-EHT2DRT4.js";
 
 // src/agents/cursor-runner.ts
-import { mkdirSync } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
 import { createInterface } from "readline";
 
+// src/agents/cursor-catalog.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join } from "path";
+import lockfile from "proper-lockfile";
+var CATALOG_FILES = ["agents.ndjson", "runs.ndjson", "run_events.ndjson", "checkpoints.ndjson"];
+var INTERRUPTED_TMP = /^\.(agents|runs|run_events|checkpoints)\.ndjson\.[0-9a-f]{16}\.tmp$/;
+async function acquireCursorCatalogLock(storeDir) {
+  mkdirSync(storeDir, { recursive: true });
+  const lockPath = join(storeDir, ".catalog.lock");
+  writeFileSync(lockPath, "", { flag: "a" });
+  try {
+    return await lockfile.lock(lockPath, {
+      retries: { retries: 40, minTimeout: 50, maxTimeout: 500 },
+      stale: 5e3,
+      update: 2e3
+    });
+  } catch {
+    return async () => {
+    };
+  }
+}
+var heldCatalogRelease;
+function publishRepair(repair, note) {
+  for (const line of repair.notes) note(line);
+}
+async function openCursorCatalogTurn(storeDir, note) {
+  mkdirSync(storeDir, { recursive: true });
+  heldCatalogRelease = await acquireCursorCatalogLock(storeDir);
+  publishRepair(repairCursorLocalCatalog(storeDir), note);
+}
+function repairCursorCatalogForResume(storeDir, note) {
+  const repair = repairCursorLocalCatalog(storeDir);
+  publishRepair(repair, note);
+  return repair.repaired;
+}
+async function closeCursorCatalogTurn() {
+  const release = heldCatalogRelease;
+  heldCatalogRelease = void 0;
+  if (release) await release().catch(() => void 0);
+}
+function repairCursorLocalCatalog(storeDir) {
+  if (!existsSync(storeDir)) return { repaired: false, notes: [] };
+  const notes = [];
+  let repaired = false;
+  const loaded = /* @__PURE__ */ new Map();
+  for (const file of CATALOG_FILES) {
+    loaded.set(file, loadCatalogFile(storeDir, file));
+  }
+  const checkpoints = mergeByKey(
+    loaded.get("checkpoints.ndjson").main,
+    loaded.get("checkpoints.ndjson").tmpRows,
+    (row) => checkpointKey(row),
+    (main2) => main2
+  );
+  const blobs = checkpointBlobs(checkpoints.rows);
+  const agents = mergeByKey(
+    loaded.get("agents.ndjson").main,
+    loaded.get("agents.ndjson").tmpRows,
+    (row) => typeof row.agentId === "string" ? row.agentId : null,
+    (main2, extra) => preferAgent(main2, extra, blobs)
+  );
+  const runs = mergeByKey(
+    loaded.get("runs.ndjson").main,
+    loaded.get("runs.ndjson").tmpRows,
+    (row) => runKey(row),
+    (main2, extra) => num(extra.updatedAt) >= num(main2.updatedAt) ? extra : main2
+  );
+  const events = mergeByKey(
+    loaded.get("run_events.ndjson").main,
+    loaded.get("run_events.ndjson").tmpRows,
+    (row) => eventKey(row),
+    (main2) => main2
+  );
+  const merged = {
+    "checkpoints.ndjson": checkpoints.rows,
+    "agents.ndjson": agents.rows,
+    "runs.ndjson": runs.rows,
+    "run_events.ndjson": events.rows
+  };
+  for (const agent of merged["agents.ndjson"]) {
+    if (restoreAgentCheckpoint(agent, merged["runs.ndjson"], blobs, notes)) repaired = true;
+    if (clearMissingActiveRun(agent, merged["runs.ndjson"], notes)) repaired = true;
+  }
+  for (const file of CATALOG_FILES) {
+    const prior = loaded.get(file);
+    const next = merged[file];
+    const recovered = countNewKeys(prior.main, next, keyFor(file));
+    if (recovered > 0) {
+      notes.push(`Cursor catalog recovered ${recovered} ${file} row(s) from an interrupted write`);
+      repaired = true;
+    }
+    if (!sameRows(prior.main, next)) {
+      writeCatalogFile(join(storeDir, file), next);
+      repaired = true;
+    }
+    for (const tmp of prior.tmps) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+    }
+  }
+  return { repaired, notes };
+}
+function loadCatalogFile(storeDir, file) {
+  const tmps = interruptedTmps(storeDir, file);
+  return {
+    main: readRows(join(storeDir, file)),
+    tmps,
+    tmpRows: tmps.flatMap((tmp) => readRows(tmp))
+  };
+}
+function keyFor(file) {
+  if (file === "checkpoints.ndjson") return checkpointKey;
+  if (file === "agents.ndjson") return (row) => typeof row.agentId === "string" ? row.agentId : null;
+  if (file === "runs.ndjson") return runKey;
+  return eventKey;
+}
+function countNewKeys(main2, next, keyOf) {
+  const had = new Set(main2.map(keyOf).filter((key) => Boolean(key)));
+  let n = 0;
+  for (const row of next) {
+    const key = keyOf(row);
+    if (key && !had.has(key)) n += 1;
+  }
+  return n;
+}
+function interruptedTmps(storeDir, file) {
+  let names = [];
+  try {
+    names = readdirSync(storeDir);
+  } catch {
+    return [];
+  }
+  const prefix = `.${file}.`;
+  return names.filter((name) => name.startsWith(prefix) && INTERRUPTED_TMP.test(name)).map((name) => join(storeDir, name));
+}
+function readRows(file) {
+  if (!existsSync(file)) return [];
+  let raw = "";
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isRow(parsed)) rows.push(parsed);
+    } catch {
+    }
+  }
+  return rows;
+}
+function writeCatalogFile(file, rows) {
+  if (rows.length === 0 && !existsSync(file)) return;
+  const body = rows.map((row) => JSON.stringify(row)).join("\n");
+  const dir = dirname(file);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${basename(file)}.repair.tmp`);
+  writeFileSync(tmp, body);
+  renameSync(tmp, file);
+}
+function mergeByKey(main2, extra, keyOf, prefer) {
+  const out = [];
+  const index = /* @__PURE__ */ new Map();
+  for (const row of main2) {
+    const key = keyOf(row);
+    if (!key || index.has(key)) continue;
+    index.set(key, out.length);
+    out.push(structuredClone(row));
+  }
+  for (const row of extra) {
+    const key = keyOf(row);
+    if (!key) continue;
+    const at = index.get(key);
+    if (at == null) {
+      index.set(key, out.length);
+      out.push(structuredClone(row));
+      continue;
+    }
+    out[at] = structuredClone(prefer(out[at], row));
+  }
+  return { rows: out };
+}
+function restoreAgentCheckpoint(agent, runs, blobs, notes) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const current = rootBlobId(agent.latestCheckpoint);
+  if (!agentId || !current || blobs.has(`${agentId}\0${current}`)) return false;
+  const fallback = fallbackCheckpoint(runs, agentId, blobs);
+  const fallbackId = rootBlobId(fallback);
+  if (!fallback || !fallbackId) return false;
+  agent.latestCheckpoint = fallback;
+  agent.updatedAt = Date.now();
+  notes.push(
+    `Cursor catalog restored agent ${agentId} to checkpoint ${fallbackId} (root blob ${current} was missing)`
+  );
+  return true;
+}
+function clearMissingActiveRun(agent, runs, notes) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const active = typeof agent.activeRunId === "string" ? agent.activeRunId : "";
+  if (!agentId || !active) return false;
+  const live = runs.some((run) => run.agentId === agentId && run.runId === active);
+  if (live) return false;
+  agent.activeRunId = null;
+  if (agent.status === "running") agent.status = "idle";
+  notes.push(`Cursor catalog cleared missing run ${active} on agent ${agentId}`);
+  return true;
+}
+function fallbackCheckpoint(runs, agentId, blobs) {
+  const mine = runs.filter((run) => run.agentId === agentId).slice().sort((a, b) => num(b.updatedAt) - num(a.updatedAt));
+  for (const run of mine) {
+    for (const field of ["latestCheckpointRef", "startCheckpointRef"]) {
+      const ref = run[field];
+      const id = rootBlobId(ref);
+      if (id && blobs.has(`${agentId}\0${id}`) && isRow(ref)) return ref;
+    }
+  }
+  return null;
+}
+function preferAgent(main2, extra, blobs) {
+  const mainOk = checkpointPresent(main2, blobs);
+  const extraOk = checkpointPresent(extra, blobs);
+  if (mainOk && !extraOk) return main2;
+  if (extraOk && !mainOk) return extra;
+  return num(extra.updatedAt) >= num(main2.updatedAt) ? extra : main2;
+}
+function checkpointPresent(agent, blobs) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const id = rootBlobId(agent.latestCheckpoint);
+  if (!id) return true;
+  return blobs.has(`${agentId}\0${id}`);
+}
+function checkpointBlobs(rows) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (typeof row.agentId !== "string" || typeof row.blobId !== "string") continue;
+    if (typeof row.dataBase64 !== "string" || !row.dataBase64) continue;
+    ids.add(`${row.agentId}\0${row.blobId}`);
+  }
+  return ids;
+}
+function checkpointKey(row) {
+  if (typeof row.agentId !== "string" || typeof row.blobId !== "string") return null;
+  return `${row.agentId}\0${row.blobId}`;
+}
+function runKey(row) {
+  if (typeof row.agentId !== "string" || typeof row.runId !== "string") return null;
+  return `${row.agentId}\0${row.runId}`;
+}
+function eventKey(row) {
+  if (typeof row.runId !== "string") return null;
+  if (typeof row.seq === "number") return `${row.runId}\0${row.seq}`;
+  if (typeof row.offset === "string") return `${row.runId}\0${row.offset}`;
+  return null;
+}
+function rootBlobId(ref) {
+  if (!isRow(ref) || typeof ref.rootBlobId !== "string" || !ref.rootBlobId) return null;
+  return ref.rootBlobId;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function sameRows(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function isRow(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/agents/cursor-session.ts
 function cursorErrorMessage(err) {
   if (err instanceof Error) return err.message.trim();
@@ -146,7 +428,7 @@ async function* iterateUntilIdle(iterable, idleMs, onIdle, activity) {
 }
 
 // src/agents/sliced-file-read.ts
-import { readFileSync, realpathSync, statSync } from "fs";
+import { readFileSync as readFileSync2, realpathSync, statSync } from "fs";
 import { isAbsolute, relative, resolve, sep } from "path";
 var SLICED_READ_DEFAULT_LIMIT = 200;
 var SLICED_READ_MAX_LINE_CHARS = 2e3;
@@ -221,7 +503,7 @@ function executeSlicedFileRead(cwd, args) {
   try {
     const st = statSync(abs);
     if (!st.isFile()) return `Error: not a file: ${rawPath}`;
-    buf = readFileSync(abs);
+    buf = readFileSync2(abs);
   } catch (err) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -306,7 +588,7 @@ function emit(event) {
 }
 function localAgentStore(Store, threadId) {
   const root = cursorSdkStoreDir(threadId);
-  mkdirSync(root, { recursive: true });
+  mkdirSync2(root, { recursive: true });
   return new Store(root);
 }
 async function cancelStaleRuns(Agent, agentId, opts) {
@@ -396,6 +678,9 @@ async function main() {
     fast: Boolean(req.fast)
   });
   const mode = req.planMode ? "plan" : "agent";
+  const storeRoot = cursorSdkStoreDir(req.threadId);
+  const note = (line) => emit({ type: "stderr", data: line });
+  await openCursorCatalogTurn(storeRoot, note);
   const store = localAgentStore(JsonlLocalAgentStore, req.threadId);
   const isolateSources = [];
   let onRpcProgress = () => {
@@ -444,20 +729,22 @@ async function main() {
   async function createAgent() {
     return retryTransport(() => Agent.create(createOpts));
   }
+  function resumeAgent(agentId) {
+    const { name: _name, ...opts } = createOpts;
+    return retryTransport(() => Agent.resume(agentId, opts));
+  }
   async function openAgent() {
     try {
-      return req.agentId ? await retryTransport(
-        () => Agent.resume(req.agentId, {
-          apiKey,
-          model,
-          mode,
-          local,
-          disallowedTools: ["read"],
-          ...mcpServers ? { mcpServers } : {}
-        })
-      ) : await createAgent();
+      return req.agentId ? await resumeAgent(req.agentId) : await createAgent();
     } catch (err) {
       if (!isUnresumableCursorSession(err)) throw err;
+      if (repairCursorCatalogForResume(storeRoot, note) && req.agentId) {
+        try {
+          return await resumeAgent(req.agentId);
+        } catch (err2) {
+          if (!isUnresumableCursorSession(err2)) throw err2;
+        }
+      }
       emit({
         type: "stderr",
         data: cursorSessionRecoveryMessage(err, req.agentId)
@@ -511,7 +798,9 @@ async function main() {
       new Promise((resolve2) => {
         setTimeout(resolve2, 2e3);
       })
-    ]).finally(() => process.exit(1));
+    ]).finally(() => {
+      void closeCursorCatalogTurn().finally(() => process.exit(1));
+    });
   };
   process.once("SIGTERM", onSignal);
   process.once("SIGINT", onSignal);
@@ -609,11 +898,21 @@ async function main() {
           return await runTurn(agent);
         }
         if (!isUnresumableCursorSession(err)) throw err;
+        const agentId = agent.agentId;
+        await agent[Symbol.asyncDispose]().catch(() => void 0);
+        const repaired = repairCursorCatalogForResume(storeRoot, note);
+        if (repaired) {
+          try {
+            agent = await resumeAgent(agentId);
+            return await runTurn(agent);
+          } catch (err2) {
+            if (!isUnresumableCursorSession(err2)) throw err2;
+          }
+        }
         emit({
           type: "stderr",
-          data: cursorSessionRecoveryMessage(err, agent.agentId)
+          data: cursorSessionRecoveryMessage(err, agentId)
         });
-        await agent[Symbol.asyncDispose]().catch(() => void 0);
         agent = await createAgent();
         return await runTurn(agent);
       }
@@ -631,6 +930,8 @@ async function main() {
     const message = err instanceof Error ? err.message : String(err);
     emit({ type: "stderr", data: message });
     return 1;
+  } finally {
+    await closeCursorCatalogTurn();
   }
 }
 main().then(

package/dist/{agents-4BBCKITL.js → agents-SITR5V6F.js}

@@ -37,7 +37,7 @@ import {
   planModeTurnInstruction,
   resolveCursorModelId,
   resolveQuotaFallbackAgent
-} from "./chunk-VNCPRMIK.js";
+} from "./chunk-XZW3BXZW.js";
 import "./chunk-VGNLMGBK.js";
 import "./chunk-YSLCWCMJ.js";
 import {
@@ -52,8 +52,8 @@ import {
   resolveLoginCommand,
   whichOnPath
 } from "./chunk-NXXQFLNQ.js";
-import "./chunk-V3BSO2O6.js";
-import "./chunk-2IXKTAIT.js";
+import "./chunk-ZRQWV3MS.js";
+import "./chunk-2VGLZIU6.js";
 import "./chunk-QB5MDOHL.js";
 import "./chunk-2P4XKWV2.js";
 import "./chunk-33KDPEK4.js";

package/dist/{agents-XAKSP653.js → agents-WT72O5A3.js}

@@ -46,7 +46,7 @@ import {
   resolveCursorSdkRoot,
   resolveQuotaFallbackAgent,
   turnCostUsdFromCursorUsage
-} from "./chunk-LUQ7MIVD.js";
+} from "./chunk-RPCKGO3J.js";
 import {
   getAgentSetupInfo,
   installAgent,
@@ -63,8 +63,8 @@ import "./chunk-7IAMHN2N.js";
 import "./chunk-PXMLMBMI.js";
 import "./chunk-2GPQZZLY.js";
 import "./chunk-AFLNFGGB.js";
-import "./chunk-O4324MXE.js";
-import "./chunk-5HPMKLJ7.js";
+import "./chunk-PO3PDNMV.js";
+import "./chunk-UO5C2L2G.js";
 import "./chunk-N2WW62LF.js";
 import "./chunk-DD67JWTN.js";
 import {

package/dist/{chunk-2IXKTAIT.js → chunk-2VGLZIU6.js}

@@ -2021,15 +2021,8 @@ async function fetchOriginForWorktree(repoPath, sourceRef, opts) {
 async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
   try {
     const branch = opts?.branch?.trim() || await resolveDefaultBranch(repoPath, { network: false });
-    const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], repoPath, {
-      reject: false
-    });
-    const current = head.stdout.trim();
-    if (head.exitCode !== 0 || !current || current === "HEAD" || current !== branch) {
-      return { updated: false, reason: "not-on-default" };
-    }
-    if (await isDirty(repoPath)) {
-      return { updated: false, reason: "dirty" };
+    if (!branch || branch === "HEAD" || branch.includes("..")) {
+      return { updated: false, reason: "ff-failed" };
     }
     const remote = `origin/${branch}`;
     const remoteOk = await git(["rev-parse", "--verify", remote], repoPath, {
@@ -2038,8 +2031,27 @@ async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
     if (remoteOk.exitCode !== 0) {
       return { updated: false, reason: "no-origin-tip" };
     }
+    const worktrees = await listWorktrees(repoPath);
+    if (worktrees.length === 0) {
+      return { updated: false, reason: "ff-failed" };
+    }
+    const checkout = worktrees.find((entry) => entry.branch === branch) ?? null;
+    const localRef = `refs/heads/${branch}`;
+    const localOk = await git(["rev-parse", "--verify", localRef], repoPath, {
+      reject: false
+    });
+    if (localOk.exitCode !== 0) {
+      if (checkout) return { updated: false, reason: "ff-failed" };
+      const created = await git(["branch", "--track", branch, remote], repoPath, {
+        reject: false
+      });
+      if (created.exitCode !== 0) {
+        return { updated: false, reason: "ff-failed" };
+      }
+      return { updated: true, reason: "updated" };
+    }
     const ancestor = await git(
-      ["merge-base", "--is-ancestor", "HEAD", remote],
+      ["merge-base", "--is-ancestor", localRef, remote],
       repoPath,
       { reject: false }
     );
@@ -2047,7 +2059,7 @@ async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
       return { updated: false, reason: "diverged" };
     }
     const behind = await git(
-      ["rev-list", "--count", `HEAD..${remote}`],
+      ["rev-list", "--count", `${localRef}..${remote}`],
       repoPath,
       { reject: false }
     );
@@ -2055,10 +2067,22 @@ async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
     if (behind.exitCode !== 0 || !Number.isFinite(n) || n <= 0) {
       return { updated: false, reason: "already-current" };
     }
-    const ff = await git(["merge", "--ff-only", remote], repoPath, {
+    if (checkout) {
+      if (await isDirty(checkout.path)) {
+        return { updated: false, reason: "dirty" };
+      }
+      const ff = await git(["merge", "--ff-only", remote], checkout.path, {
+        reject: false
+      });
+      if (ff.exitCode !== 0) {
+        return { updated: false, reason: "ff-failed" };
+      }
+      return { updated: true, reason: "updated" };
+    }
+    const moved = await git(["branch", "-f", branch, remote], repoPath, {
       reject: false
     });
-    if (ff.exitCode !== 0) {
+    if (moved.exitCode !== 0) {
       return { updated: false, reason: "ff-failed" };
     }
     return { updated: true, reason: "updated" };

package/dist/{chunk-GBAACE3C.js → chunk-4YXXLWDI.js}

@@ -8,11 +8,11 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   isSlackCoordinatorThread
-} from "./chunk-V3BSO2O6.js";
+} from "./chunk-ZRQWV3MS.js";
 import {
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv
-} from "./chunk-2IXKTAIT.js";
+} from "./chunk-2VGLZIU6.js";
 import {
   allocateTeamName,
   createEmptyThread,
@@ -1776,7 +1776,7 @@ var PORT_RANGE_SIZE = 10;
 var RECLAIM_RETRY_DELAY_MS = 40;
 var RECLAIM_TRIES = 8;
 async function killReclaimable(ports, worktreePath, signal) {
-  const { killListenersOnPorts: killListenersOnPorts2, killStaleWorktreeListeners: killStaleWorktreeListeners2 } = await import("./conductor-UFJXJPTF.js");
+  const { killListenersOnPorts: killListenersOnPorts2, killStaleWorktreeListeners: killStaleWorktreeListeners2 } = await import("./conductor-MAYZSFL6.js");
   if (worktreePath) killStaleWorktreeListeners2(ports, worktreePath, signal);
   else killListenersOnPorts2(ports);
 }

package/dist/{chunk-4VXWLY3L.js → chunk-IP5WSADC.js}

@@ -27,7 +27,7 @@ import {
   parseSessionQuotaResetAt,
   planModeTurnInstruction,
   resolveQuotaFallbackAgent
-} from "./chunk-LUQ7MIVD.js";
+} from "./chunk-RPCKGO3J.js";
 import {
   REVIEW_TAB_TITLE,
   applyWorktreePkgCacheEnv,
@@ -66,7 +66,7 @@ import {
   worktreeDevProcessKey,
   worktreeRunProcessKey,
   worktreeSetupProcessKey
-} from "./chunk-G74TSBJ3.js";
+} from "./chunk-WRDKJRWF.js";
 import {
   applyAgentEvent,
   clipAgentEventForPaint,
@@ -118,7 +118,7 @@ import {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads
-} from "./chunk-O4324MXE.js";
+} from "./chunk-PO3PDNMV.js";
 import {
   addPrStackLayer,
   allocateTeamSlug,
@@ -160,7 +160,7 @@ import {
   resolveRepoRoot,
   switchWorktreeBranch,
   withRepoGitLock
-} from "./chunk-5HPMKLJ7.js";
+} from "./chunk-UO5C2L2G.js";
 import {
   clearStaleIndexLocks,
   enrichPathWithNpmGlobalBin,
@@ -503,9 +503,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-BTH2YGDZ.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-CTFQDG7G.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-BYPEW6DE.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-OZFKNCM3.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -3119,7 +3119,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { addWorkspace: addWorkspace2 } = await import("./workspaces-ELO2YVTU.js");
+  const { addWorkspace: addWorkspace2 } = await import("./workspaces-QNKFBA63.js");
   await addWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored } = await import("./worktree-exclude-5N2KTYIT.js");
   await ensureWorktreeSideboardIgnored(input.worktreePath);
@@ -5994,7 +5994,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-EQSK2RMI.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-4QVF6CE2.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -8866,7 +8866,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-ADVQ6X6C.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-EMCWDPZJ.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({