@sideboard-ai/core 0.1.212 → 0.1.214

package/dist/{agents-GQANI7M5.js → agents-HETHRRZJ.js}

@@ -44,9 +44,9 @@ import {
   resolveLoginCommand,
   resolveQuotaFallbackAgent,
   whichOnPath
-} from "./chunk-IRCAWYTN.js";
-import "./chunk-2PE6SZCM.js";
-import "./chunk-NRKDRQM3.js";
+} from "./chunk-DFTVZEZY.js";
+import "./chunk-FNGXKY5W.js";
+import "./chunk-NI243N27.js";
 import "./chunk-6K64FJDD.js";
 import "./chunk-QQKDGPUI.js";
 import "./chunk-SALM35KD.js";
@@ -67,7 +67,7 @@ import {
 import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
 import "./chunk-JT7R45JB.js";
-import "./chunk-JJ3ONQ4Q.js";
+import "./chunk-3IMSQNTS.js";
 import "./chunk-7J72QJOM.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-WFUDY6PC.js";

package/dist/{agents-A2U3K7VK.js → agents-WBDDLRBY.js}

@@ -50,14 +50,14 @@ import {
   resolveQuotaFallbackAgent,
   turnCostUsdFromCursorUsage,
   whichOnPath
-} from "./chunk-IA5IPGZI.js";
-import "./chunk-WNVQJZ7P.js";
+} from "./chunk-7MTVRNP4.js";
+import "./chunk-KFD2OXCE.js";
 import "./chunk-3OHR73VK.js";
 import "./chunk-Y4MIXGPA.js";
 import "./chunk-VKQGAWHY.js";
-import "./chunk-VPQXJYIW.js";
+import "./chunk-XYKVRRC2.js";
 import "./chunk-D6JWYJ4P.js";
-import "./chunk-GHKFSBES.js";
+import "./chunk-HY2GFZ5S.js";
 import "./chunk-X5B3OS5I.js";
 import "./chunk-SYFVUF2C.js";
 import {

package/dist/{chunk-JJ3ONQ4Q.js → chunk-3IMSQNTS.js}

@@ -144,6 +144,7 @@ function forgetThread(id) {
   const cache = cacheForDir();
   cache.byId.delete(id);
   cache.mtimeMs.delete(id);
+  selfWriteMtimes.delete(id);
 }
 function invalidateThreadListCache() {
   listCache = null;
@@ -167,20 +168,28 @@ function readThread(id) {
   rememberThread(thread, mtimeMs);
   return thread;
 }
+var selfWriteMtimes = /* @__PURE__ */ new Map();
 function writeThread(thread, opts) {
   const path = threadFilePath(idPath(thread.id));
   const tmp = `${path}.${process.pid}.tmp`;
   const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso() };
   writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
   renameSync(tmp, path);
-  rememberThread(next, fileMtimeMs(path) ?? Date.now());
+  const mtimeMs = fileMtimeMs(path) ?? Date.now();
+  rememberThread(next, mtimeMs);
+  selfWriteMtimes.set(thread.id, mtimeMs);
+}
+function isSelfWrittenRecord(id) {
+  const ours = selfWriteMtimes.get(id);
+  if (ours == null) return false;
+  return fileMtimeMs(threadFilePath(id)) === ours;
 }
 function idPath(id) {
   return id;
 }
 function isThreadRecordFile(nameOrPath) {
   const name = basename(nameOrPath);
-  return name.endsWith(".json") && !name.endsWith(".live.json");
+  return name.endsWith(".json") && !name.endsWith(".live.json") && !name.endsWith(".setup.log.json");
 }
 function listThreads(opts) {
   const cache = cacheForDir();
@@ -256,6 +265,7 @@ export {
   invalidateThreadRecord,
   readThread,
   writeThread,
+  isSelfWrittenRecord,
   isThreadRecordFile,
   listThreads,
   deleteThreadRecord,

package/dist/{chunk-IA5IPGZI.js → chunk-7MTVRNP4.js}

@@ -2,7 +2,7 @@
 
 import {
   isOrchestratorThread
-} from "./chunk-WNVQJZ7P.js";
+} from "./chunk-KFD2OXCE.js";
 import {
   applyConnectedTeamToCli,
   brightsyMcpServerName,
@@ -20,7 +20,7 @@ import {
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv,
   resolveCodexGitWritableRoots
-} from "./chunk-VPQXJYIW.js";
+} from "./chunk-XYKVRRC2.js";
 import {
   enrichPathWithNpmGlobalBin,
   isConductorBundledCli,
@@ -2414,7 +2414,7 @@ var claudeAdapter = {
       );
     }
     const mode = permissionMode(thread);
-    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-RHABXQWB.js");
+    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-KT3FRHZL.js");
     const isOrchestrator = isOrchestratorThread2(thread);
     const injectedServers = await buildInjectedMcpServers({
       includeSideboard: true,

package/dist/{chunk-DINKOGEU.js → chunk-C32SBNA3.js}

@@ -24,7 +24,7 @@ import {
   resolveQuotaFallbackAgent,
   stripBrightsyNdjsonNoise,
   toolDescription
-} from "./chunk-IRCAWYTN.js";
+} from "./chunk-DFTVZEZY.js";
 import {
   SLACK_REPLY_FORMATTING,
   addWorkspace,
@@ -47,7 +47,7 @@ import {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads
-} from "./chunk-2PE6SZCM.js";
+} from "./chunk-FNGXKY5W.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -97,7 +97,7 @@ import {
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath,
   worktreeSlugForTicket
-} from "./chunk-NRKDRQM3.js";
+} from "./chunk-NI243N27.js";
 import {
   ATTACHMENTS_DIR,
   DETACHED_JOBS_DIR,
@@ -189,7 +189,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-JJ3ONQ4Q.js";
+} from "./chunk-3IMSQNTS.js";
 import {
   appDataDir,
   findConventionSetup,
@@ -483,7 +483,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-333M3JAU.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-WVZPTHBV.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -817,9 +817,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-NG2TBUI5.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-6P236KKG.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-LMTMWCPN.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-FQX6ALAI.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -2377,6 +2377,29 @@ ${line}` : line;
 }
 var memory = /* @__PURE__ */ new Map();
 var persistTimers = /* @__PURE__ */ new Map();
+function fromSnapshot(snap) {
+  return {
+    chunks: snap.output ? [snap.output] : [],
+    length: snap.output.length,
+    running: snap.running,
+    exitCode: snap.exitCode,
+    source: snap.source
+  };
+}
+function materialize(mem) {
+  let output = mem.chunks.join("\n");
+  if (output.length > MAX_SETUP_LOG_CHARS) {
+    output = appendSetupOutput("", output);
+    mem.chunks = [output];
+    mem.length = output.length;
+  }
+  return {
+    output,
+    running: mem.running,
+    exitCode: mem.exitCode,
+    source: mem.source
+  };
+}
 function setupLogPath(threadId) {
   return join7(threadsDir(), `${threadId}.setup.log.json`);
 }
@@ -2395,20 +2418,22 @@ function mergeSetupOutput(prev, incoming) {
   if (incoming.startsWith(prev) || incoming.endsWith(prev)) return incoming;
   return incoming.length >= prev.length ? incoming : prev;
 }
-function clone(snap) {
-  return { ...snap };
-}
+var PERSIST_DEBOUNCE_MS = 500;
 function persistNow(threadId) {
   const timer = persistTimers.get(threadId);
   if (timer) {
     clearTimeout(timer);
     persistTimers.delete(threadId);
   }
-  const snap = memory.get(threadId);
-  if (!snap) return;
+  const mem = memory.get(threadId);
+  if (!mem) return;
   try {
-    writeFileSync2(setupLogPath(threadId), `${JSON.stringify(snap)}
-`, "utf8");
+    writeFileSync2(
+      setupLogPath(threadId),
+      `${JSON.stringify(materialize(mem))}
+`,
+      "utf8"
+    );
   } catch {
   }
 }
@@ -2419,7 +2444,7 @@ function schedulePersist(threadId) {
     setTimeout(() => {
       persistTimers.delete(threadId);
       persistNow(threadId);
-    }, 100)
+    }, PERSIST_DEBOUNCE_MS)
   );
 }
 function loadFromDisk(threadId) {
@@ -2437,49 +2462,50 @@ function loadFromDisk(threadId) {
     return null;
   }
 }
+function memFor(threadId) {
+  const cached = memory.get(threadId);
+  if (cached) return cached;
+  const mem = fromSnapshot(loadFromDisk(threadId) ?? emptySetupLog());
+  memory.set(threadId, mem);
+  return mem;
+}
 function readSetupLog(threadId) {
   const cached = memory.get(threadId);
-  if (cached) return clone(cached);
+  if (cached) return materialize(cached);
   const disk = loadFromDisk(threadId);
   if (disk) {
-    memory.set(threadId, disk);
-    return clone(disk);
+    memory.set(threadId, fromSnapshot(disk));
+    return disk;
   }
   return emptySetupLog();
 }
 function beginSetupLog(threadId) {
-  const snap = {
-    output: "",
+  const mem = {
+    chunks: [],
+    length: 0,
     running: true,
     exitCode: null,
     source: null
   };
-  memory.set(threadId, snap);
+  memory.set(threadId, mem);
   persistNow(threadId);
-  return clone(snap);
+  return materialize(mem);
 }
 function appendSetupLog(threadId, line) {
-  const current = memory.get(threadId) ?? readSetupLog(threadId);
-  const snap = {
-    ...current,
-    output: appendSetupOutput(current.output, line),
-    running: true
-  };
-  memory.set(threadId, snap);
+  const mem = memFor(threadId);
+  mem.chunks.push(line);
+  mem.length += line.length + 1;
+  mem.running = true;
+  if (mem.length > MAX_SETUP_LOG_CHARS * 2) materialize(mem);
   schedulePersist(threadId);
-  return clone(snap);
 }
 function finishSetupLog(threadId, exitCode, source) {
-  const current = memory.get(threadId) ?? readSetupLog(threadId);
-  const snap = {
-    ...current,
-    running: false,
-    exitCode,
-    source: source ?? current.source
-  };
-  memory.set(threadId, snap);
+  const mem = memFor(threadId);
+  mem.running = false;
+  mem.exitCode = exitCode;
+  mem.source = source ?? mem.source;
   persistNow(threadId);
-  return clone(snap);
+  return materialize(mem);
 }
 
 // src/git/orphan-cleanup.ts
@@ -4039,7 +4065,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-GQANI7M5.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-HETHRRZJ.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -4071,6 +4097,33 @@ function shouldRemoveWorktreeOnTeardown(thread) {
   return !isCowboyThread(thread) && !isPrimaryCheckoutThread(thread);
 }
 
+// src/util/line-coalescer.ts
+function createLineCoalescer(onChunk, opts) {
+  const delayMs = opts?.delayMs ?? 50;
+  const maxLines = opts?.maxLines ?? 200;
+  let buffer = [];
+  let timer = null;
+  const flush2 = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (buffer.length === 0) return;
+    const chunk = buffer.join("\n");
+    buffer = [];
+    onChunk(chunk);
+  };
+  const push = (line) => {
+    buffer.push(line);
+    if (buffer.length >= maxLines) {
+      flush2();
+      return;
+    }
+    if (!timer) timer = setTimeout(flush2, delayMs);
+  };
+  return { push, flush: flush2 };
+}
+
 // src/store/turn-live.ts
 import {
   existsSync as existsSync11,
@@ -4485,7 +4538,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-FRR6Y4BY.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-R5LJCJRB.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-X54WSOXM.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
@@ -5705,6 +5758,29 @@ function writeWorktreeFile(worktreePath, relativePath, content) {
   writeFileSync6(abs, content, "utf8");
   return { path: relativePath };
 }
+async function getWorktreeDirtyStat(worktreePath) {
+  const status = await inspectGitWorktree(worktreePath);
+  if (status !== "ok") {
+    return { additions: 0, deletions: 0, dirty: false };
+  }
+  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+    reject: false,
+    timeoutMs: 4e3
+  });
+  if (head.exitCode !== 0) {
+    return { additions: 0, deletions: 0, dirty: await isDirty(worktreePath) };
+  }
+  const [num, dirty] = await Promise.all([
+    gitDiff(["--numstat", "HEAD"], worktreePath, { timeoutMs: 4e3 }),
+    isDirty(worktreePath)
+  ]);
+  const counts = statFromNumstat(num.stdout);
+  return {
+    additions: counts.additions,
+    deletions: counts.deletions,
+    dirty: dirty || counts.additions > 0 || counts.deletions > 0
+  };
+}
 async function getDiffSummary(worktreePath, repoPath, opts) {
   const full = await getDiff(worktreePath, repoPath, {
     maxHunkChars: opts?.maxHunkChars ?? 2e3,
@@ -7121,7 +7197,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-333M3JAU.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-WVZPTHBV.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -7252,6 +7328,7 @@ function resolveOrchChildFollowUp(requested) {
   return followUpBehavior();
 }
 var STALE_AGENT_PID_WAIT_MS = 2500;
+var LIGHT_RECONCILE_THROTTLE_MS = 1e4;
 function writeLiveStatus(threadId, status, lastError) {
   const latest = readThread(threadId);
   if (!latest || latest.status === "archived") return latest;
@@ -7266,6 +7343,8 @@ var Orchestrator = class {
   startingTurns = /* @__PURE__ */ new Set();
   /** Last sync thread-file read for false-stop heal (throttled per thread). */
   lastReconcileHealAt = /* @__PURE__ */ new Map();
+  /** Per-repo timestamp of the last `reconcile(repo, { light: true })`. */
+  lightReconcileAt = /* @__PURE__ */ new Map();
   /**
    * Threads intentionally force-stopped. Prevents runTurn from re-asserting
    * `running` after spawn, and from overwriting `stopped` with idle/error when
@@ -7351,6 +7430,20 @@ var Orchestrator = class {
   async reconcile(repoPath, opts) {
     const reclaimStaleTurns = opts?.reclaimStaleTurns === true;
     const drainQueues = opts?.drainQueues !== false;
+    if (opts?.light && repoPath) {
+      const last = this.lightReconcileAt.get(repoPath) ?? 0;
+      if (Date.now() - last < LIGHT_RECONCILE_THROTTLE_MS) return;
+      this.lightReconcileAt.set(repoPath, Date.now());
+      for (const thread of listThreads()) {
+        if (isGlobalThread(thread) || thread.repoPath !== repoPath) continue;
+        if (!existsSync19(thread.worktreePath)) {
+          setStatus(thread.id, "broken", "Worktree missing on disk");
+          this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
+        }
+      }
+      await this.reconcileOrphans([repoPath]);
+      return;
+    }
     healOrchestrationSoccerTitles();
     for (const thread of listThreads({ includeArchived: true })) {
       if (thread.status === "archived") continue;
@@ -7383,6 +7476,21 @@ var Orchestrator = class {
       }
     }
     const repoPaths = (repoPath ? [repoPath] : [...new Set(listThreads({ includeArchived: true }).map((t) => t.repoPath))]).filter((p) => !isGlobalRepoPath(p));
+    await this.reconcileOrphans(repoPaths);
+    try {
+      if (shouldRunHistoryCleanup()) {
+        cleanupArchivedHistory();
+      }
+    } catch {
+    }
+    if (drainQueues) {
+      this.adoptPersistedQueues();
+    }
+    this.schedulePendingQuotaResumes();
+    armSchedules();
+  }
+  /** Surface (and, when enabled, clean up) worktrees git knows about but no thread owns. */
+  async reconcileOrphans(repoPaths) {
     try {
       const orphans = await findOrphanWorktrees(repoPaths);
       if (orphans.length) {
@@ -7397,17 +7505,6 @@ var Orchestrator = class {
       }
     } catch {
     }
-    try {
-      if (shouldRunHistoryCleanup()) {
-        cleanupArchivedHistory();
-      }
-    } catch {
-    }
-    if (drainQueues) {
-      this.adoptPersistedQueues();
-    }
-    this.schedulePendingQuotaResumes();
-    armSchedules();
   }
   /**
    * Adopt queues persisted by another process (MCP stdio / CLI) into this
@@ -7641,7 +7738,7 @@ var Orchestrator = class {
     return listThreads({ includeArchived });
   }
   getThread(idOrRef) {
-    return findThreadByRef(idOrRef) ?? readThread(idOrRef);
+    return readThread(idOrRef) ?? findThreadByRef(idOrRef);
   }
   async createThread(input) {
     const prior = new Set(
@@ -8497,17 +8594,18 @@ var Orchestrator = class {
         }
       }
     }
+    const runOutput = createLineCoalescer((chunk) => {
+      this.emit({
+        type: "run_output",
+        threadId: thread.id,
+        scriptName: resolvedName,
+        line: chunk
+      });
+    });
     const handle = await startDevServer(
       thread.repoPath,
       thread.worktreePath,
-      (line) => {
-        this.emit({
-          type: "run_output",
-          threadId: thread.id,
-          scriptName: resolvedName,
-          line
-        });
-      },
+      runOutput.push,
       { scriptName: resolvedName }
     );
     if (!handle) {
@@ -8553,6 +8651,7 @@ var Orchestrator = class {
       scriptName: resolvedName
     });
     void handle.done.then(() => {
+      runOutput.flush();
       this.processes.delete(runKey);
       if (isDefault) this.processes.delete(worktreeDevProcessKey(thread.worktreePath));
       const latest = mergeWorktreeActiveRuns(threadsSharingWorktree(thread.worktreePath));
@@ -8638,9 +8737,14 @@ var Orchestrator = class {
       (t) => this.processes.has(`${t.id}:setup`)
     );
   }
-  writeSetupLog(threadId, worktreePath, fn) {
+  /**
+   * The worktree-keyed log is canonical (`resolveWorktreeSetupLog` prefers it
+   * whenever it has output/running/exitCode); per-chat keys only exist for
+   * records that predate it. Writing one key halves the sync persists during
+   * `pnpm install`.
+   */
+  writeSetupLog(worktreePath, fn) {
     fn(setupLogKeyForWorktree(worktreePath));
-    fn(threadId);
   }
   async runSetup(threadRef, opts) {
     const thread = this.requireThread(threadRef);
@@ -8655,14 +8759,18 @@ var Orchestrator = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       kill: () => abort.abort()
     });
-    this.writeSetupLog(thread.id, thread.worktreePath, beginSetupLog);
+    this.writeSetupLog(thread.worktreePath, beginSetupLog);
     this.emit({ type: "setup_started", threadId: thread.id });
+    const output = createLineCoalescer((chunk) => {
+      this.writeSetupLog(thread.worktreePath, (logKey) => appendSetupLog(logKey, chunk));
+      this.emit({ type: "setup_output", threadId: thread.id, line: chunk });
+    });
     let finished = false;
     const finish = (exitCode, source) => {
       if (finished) return;
       finished = true;
+      output.flush();
       this.writeSetupLog(
-        thread.id,
         thread.worktreePath,
         (logKey) => finishSetupLog(logKey, exitCode, source)
       );
@@ -8672,24 +8780,12 @@ var Orchestrator = class {
       const setup = await runWorkspaceSetup(
         thread.repoPath,
         thread.worktreePath,
-        (line) => {
-          this.writeSetupLog(
-            thread.id,
-            thread.worktreePath,
-            (logKey) => appendSetupLog(logKey, line)
-          );
-          this.emit({ type: "setup_output", threadId: thread.id, line });
-        },
+        output.push,
         { 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)";
-        this.writeSetupLog(
-          thread.id,
-          thread.worktreePath,
-          (logKey) => appendSetupLog(logKey, line)
-        );
-        this.emit({ type: "setup_output", threadId: thread.id, line });
+        output.push(line);
         finish(null, null);
         throw new Error(line);
       }
@@ -8895,6 +8991,11 @@ var Orchestrator = class {
       lastTurnBase: this.turnBaselines.get(thread.id) ?? null
     });
   }
+  async worktreeDirtyStat(threadRef) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Diff");
+    return getWorktreeDirtyStat(thread.worktreePath);
+  }
   async diffSummary(threadRef) {
     const thread = this.requireThread(threadRef);
     this.assertNotGlobal(thread, "Diff");
@@ -9343,7 +9444,7 @@ var Orchestrator = class {
     this.enforceHistoryRetention();
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-FRR6Y4BY.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-R5LJCJRB.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -9397,7 +9498,7 @@ var Orchestrator = class {
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-GKUOHXXB.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-MDMTCAHX.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -9507,7 +9608,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-GKUOHXXB.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-MDMTCAHX.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({
@@ -9517,7 +9618,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-4M6WETL6.js");
+  const { updateThread: upd } = await import("./thread-store-N6WQIWZ4.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -9723,6 +9824,7 @@ export {
   readWorktreeFileForUpload,
   readWorktreeFile,
   writeWorktreeFile,
+  getWorktreeDirtyStat,
   getDiffSummary,
   previewLand,
   confirmLand,
@@ -9776,6 +9878,7 @@ export {
   waitForPidExit,
   resolveSendFollowUp,
   resolveOrchChildFollowUp,
+  LIGHT_RECONCILE_THROTTLE_MS,
   Orchestrator,
   getOrchestrator,
   startOrchestration,