@sideboard-ai/core 0.1.211 → 0.1.213

package/dist/index.cjs

@@ -3079,6 +3079,7 @@ __export(thread_store_exports, {
   findThreadByRef: () => findThreadByRef,
   invalidateThreadListCache: () => invalidateThreadListCache,
   invalidateThreadRecord: () => invalidateThreadRecord,
+  isSelfWrittenRecord: () => isSelfWrittenRecord,
   isThreadRecordFile: () => isThreadRecordFile,
   listThreads: () => listThreads,
   normalizeThread: () => normalizeThread,
@@ -3208,6 +3209,7 @@ function forgetThread(id) {
   const cache2 = cacheForDir();
   cache2.byId.delete(id);
   cache2.mtimeMs.delete(id);
+  selfWriteMtimes.delete(id);
 }
 function invalidateThreadListCache() {
   listCache = null;
@@ -3237,14 +3239,21 @@ function writeThread(thread, opts) {
   const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso() };
   (0, import_node_fs9.writeFileSync)(tmp, JSON.stringify(next, null, 2), "utf8");
   (0, import_node_fs9.renameSync)(tmp, path2);
-  rememberThread(next, fileMtimeMs(path2) ?? Date.now());
+  const mtimeMs = fileMtimeMs(path2) ?? 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 = (0, import_node_path11.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 cache2 = cacheForDir();
@@ -3310,7 +3319,7 @@ function findThreadByRef(ref) {
     (t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref
   ) ?? null;
 }
-var import_node_crypto3, import_node_fs9, import_node_path11, import_proper_lockfile, listCache;
+var import_node_crypto3, import_node_fs9, import_node_path11, import_proper_lockfile, listCache, selfWriteMtimes;
 var init_thread_store = __esm({
   "src/store/thread-store.ts"() {
     "use strict";
@@ -3322,6 +3331,7 @@ var init_thread_store = __esm({
     init_cursor_store();
     init_paths();
     listCache = null;
+    selfWriteMtimes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -5756,6 +5766,29 @@ ${line}` : line;
   const nl = cut.indexOf("\n");
   return nl >= 0 && nl < cut.length - 1 ? cut.slice(nl + 1) : cut;
 }
+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 (0, import_node_path12.join)(threadsDir(), `${threadId}.setup.log.json`);
 }
@@ -5774,20 +5807,21 @@ 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 };
-}
 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 {
-    (0, import_node_fs10.writeFileSync)(setupLogPath(threadId), `${JSON.stringify(snap)}
-`, "utf8");
+    (0, import_node_fs10.writeFileSync)(
+      setupLogPath(threadId),
+      `${JSON.stringify(materialize(mem))}
+`,
+      "utf8"
+    );
   } catch {
   }
 }
@@ -5798,7 +5832,7 @@ function schedulePersist(threadId) {
     setTimeout(() => {
       persistTimers.delete(threadId);
       persistNow(threadId);
-    }, 100)
+    }, PERSIST_DEBOUNCE_MS)
   );
 }
 function loadFromDisk(threadId) {
@@ -5816,51 +5850,52 @@ 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);
 }
-var import_node_crypto4, import_node_fs10, import_node_path12, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers;
+var import_node_crypto4, import_node_fs10, import_node_path12, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
 var init_setup_log = __esm({
   "src/store/setup-log.ts"() {
     "use strict";
@@ -5878,6 +5913,7 @@ var init_setup_log = __esm({
     MAX_SETUP_LOG_CHARS = 256e3;
     memory = /* @__PURE__ */ new Map();
     persistTimers = /* @__PURE__ */ new Map();
+    PERSIST_DEBOUNCE_MS = 500;
   }
 });
 
@@ -19630,6 +19666,38 @@ var init_cowboy = __esm({
   }
 });
 
+// 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 };
+}
+var init_line_coalescer = __esm({
+  "src/util/line-coalescer.ts"() {
+    "use strict";
+  }
+});
+
 // src/store/turn-live.ts
 function trimParts(parts) {
   if (parts.length <= MAX_PARTS) return parts;
@@ -21295,6 +21363,29 @@ function writeWorktreeFile(worktreePath, relativePath, content) {
   (0, import_node_fs48.writeFileSync)(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 [num2, dirty] = await Promise.all([
+    gitDiff(["--numstat", "HEAD"], worktreePath, { timeoutMs: 4e3 }),
+    isDirty(worktreePath)
+  ]);
+  const counts = statFromNumstat(num2.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,
@@ -21901,9 +21992,7 @@ function consumeComposerAttachments(thread) {
   };
 }
 function takePendingTurnAttachments(thread) {
-  const pending = thread.pendingTurnAttachments ?? [];
-  if (pending.length > 0) return [...pending];
-  return thread.attachments.length > 0 ? [...thread.attachments] : [];
+  return [...thread.pendingTurnAttachments ?? []];
 }
 function alignQueueAttachments(queueLength, existing) {
   const next = (existing ?? []).slice(0, queueLength).map((slot) => [...slot ?? []]);
@@ -22767,6 +22856,7 @@ var init_title = __esm({
 // src/orchestrator/orchestrator.ts
 var orchestrator_exports = {};
 __export(orchestrator_exports, {
+  LIGHT_RECONCILE_THROTTLE_MS: () => LIGHT_RECONCILE_THROTTLE_MS,
   LIVE_TURN_SPAWN_GRACE_MS: () => LIVE_TURN_SPAWN_GRACE_MS,
   Orchestrator: () => Orchestrator,
   getOrchestrator: () => getOrchestrator,
@@ -22870,7 +22960,7 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_fs54, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
+var import_node_events, import_node_fs54, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
@@ -22904,6 +22994,7 @@ var init_orchestrator = __esm({
     init_orchestrator_capable();
     init_chat_tabs();
     init_enqueue_by_key();
+    init_line_coalescer();
     init_run();
     init_repo_git_lock();
     init_turn_live();
@@ -22937,6 +23028,7 @@ var init_orchestrator = __esm({
     init_coordinator_prompt();
     LIVE_TURN_SPAWN_GRACE_MS = 15e3;
     STALE_AGENT_PID_WAIT_MS = 2500;
+    LIGHT_RECONCILE_THROTTLE_MS = 1e4;
     Orchestrator = class {
       events = new import_node_events.EventEmitter();
       processes = /* @__PURE__ */ new Map();
@@ -22946,6 +23038,8 @@ var init_orchestrator = __esm({
       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
@@ -23031,6 +23125,20 @@ var init_orchestrator = __esm({
       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 (!(0, import_node_fs54.existsSync)(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;
@@ -23063,6 +23171,21 @@ var init_orchestrator = __esm({
           }
         }
         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) {
@@ -23077,17 +23200,6 @@ var init_orchestrator = __esm({
           }
         } catch {
         }
-        try {
-          if (shouldRunHistoryCleanup()) {
-            cleanupArchivedHistory();
-          }
-        } catch {
-        }
-        if (drainQueues) {
-          this.adoptPersistedQueues();
-        }
-        this.schedulePendingQuotaResumes();
-        armSchedules();
       }
       /**
        * Adopt queues persisted by another process (MCP stdio / CLI) into this
@@ -23321,7 +23433,7 @@ var init_orchestrator = __esm({
         return listThreads({ includeArchived });
       }
       getThread(idOrRef) {
-        return findThreadByRef(idOrRef) ?? readThread(idOrRef);
+        return readThread(idOrRef) ?? findThreadByRef(idOrRef);
       }
       async createThread(input) {
         const prior = new Set(
@@ -23492,9 +23604,11 @@ var init_orchestrator = __esm({
           const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id);
           updateThread(thread.id, {
             ...removed,
-            // Old sends parked on pendingTurnAttachments; drop that bag when the
-            // follow-up that owned it is gone so a later turn cannot inherit it.
-            ...stillQueued ? {} : { pendingTurnAttachments: [] },
+            // Follow-up files live on queueAttachments. pendingTurnAttachments is
+            // the in-flight / just-dequeued snapshot — do not wipe it when a
+            // later follow-up is removed. Only drop a leftover bag when nothing
+            // is running and the queue is empty (legacy sends that never drained).
+            ...stillQueued || inFlight ? {} : { pendingTurnAttachments: [] },
             status: !stillQueued && !inFlight && current.status === "queued" ? "idle" : current.status
           });
           this.emit({ type: "queue_changed", threadId: thread.id, queue: removed.queue });
@@ -23576,7 +23690,9 @@ var init_orchestrator = __esm({
             updateThread(threadId, {
               queue: shifted.queue,
               queueAttachments: shifted.queueAttachments,
-              ...shifted.attachments.length > 0 ? { pendingTurnAttachments: shifted.attachments } : {}
+              // Always write the snapshot, including [] for text-only, so
+              // takePending cannot fall back to leftover pending or composer files.
+              pendingTurnAttachments: shifted.attachments
             });
             this.emit({ type: "queue_changed", threadId, queue: shifted.queue });
             await this.runTurn(threadId, shifted.prompt);
@@ -23624,7 +23740,6 @@ var init_orchestrator = __esm({
           thread = this.requireThread(threadId);
         }
         const autoContinue = isJobContinuePrompt(prompt) || prompt.trim().startsWith("The previous agent process ended before it finished.");
-        const parkedSnapshot = thread.pendingTurnAttachments ?? [];
         const parked = takePendingTurnAttachments(thread);
         const sentAttachments = !autoContinue && parked.length > 0 ? parked : void 0;
         appendMessage(threadId, {
@@ -23640,7 +23755,7 @@ var init_orchestrator = __esm({
           thread.worktreePath,
           gitPrompt,
           {
-            attachments: autoContinue ? [] : sentAttachments ?? thread.attachments
+            attachments: autoContinue ? [] : sentAttachments ?? []
           }
         );
         const slackInbound = /^(Slack DM|Slack @mention)(?:\n|$)/.test(
@@ -23694,10 +23809,7 @@ var init_orchestrator = __esm({
           expandedPrompt
         ].filter(Boolean).join("\n\n");
         if (!autoContinue && sentAttachments) {
-          updateThread(
-            threadId,
-            parkedSnapshot.length > 0 ? { pendingTurnAttachments: [] } : { attachments: [], pendingTurnAttachments: [] }
-          );
+          updateThread(threadId, { pendingTurnAttachments: [] });
         }
         const adapter = getAdapter(thread.agent);
         const resolved = await adapter.resolveSessionId(thread.worktreePath, thread.sessionId);
@@ -24177,17 +24289,18 @@ var init_orchestrator = __esm({
             }
           }
         }
+        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) {
@@ -24233,6 +24346,7 @@ var init_orchestrator = __esm({
           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));
@@ -24318,9 +24432,14 @@ var init_orchestrator = __esm({
           (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);
@@ -24335,14 +24454,18 @@ var init_orchestrator = __esm({
           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)
           );
@@ -24352,24 +24475,12 @@ var init_orchestrator = __esm({
           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);
           }
@@ -24575,6 +24686,11 @@ var init_orchestrator = __esm({
           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");
@@ -25334,6 +25450,7 @@ __export(index_exports, {
   LEGACY_DETACHED_JOBS_DIR: () => LEGACY_DETACHED_JOBS_DIR,
   LEGACY_PLAN_FILE_REL: () => LEGACY_PLAN_FILE_REL,
   LEGACY_REVIEW_REQUEST_PATH: () => LEGACY_REVIEW_REQUEST_PATH,
+  LIGHT_RECONCILE_THROTTLE_MS: () => LIGHT_RECONCILE_THROTTLE_MS,
   LINEAR_OAUTH_CANCELLED: () => LINEAR_OAUTH_CANCELLED,
   LINEAR_OAUTH_PORT: () => LINEAR_OAUTH_PORT,
   LINEAR_OAUTH_REDIRECT: () => LINEAR_OAUTH_REDIRECT,
@@ -25691,6 +25808,7 @@ __export(index_exports, {
   getRunScript: () => getRunScript,
   getSchedule: () => getSchedule,
   getSlackWorkspace: () => getSlackWorkspace,
+  getWorktreeDirtyStat: () => getWorktreeDirtyStat,
   gh: () => gh,
   ghHeadRef: () => ghHeadRef,
   ghRepoSelectArgs: () => ghRepoSelectArgs,
@@ -25768,6 +25886,7 @@ __export(index_exports, {
   isPrNotMergeableError: () => isPrNotMergeableError,
   isPresentPlanToolName: () => isPresentPlanToolName,
   isPrimaryCheckoutThread: () => isPrimaryCheckoutThread,
+  isSelfWrittenRecord: () => isSelfWrittenRecord,
   isSessionQuotaLimit: () => isSessionQuotaLimit,
   isSetupLastError: () => isSetupLastError,
   isShellToolName: () => isShellToolName,
@@ -34120,6 +34239,7 @@ init_outbound_watch();
   LEGACY_DETACHED_JOBS_DIR,
   LEGACY_PLAN_FILE_REL,
   LEGACY_REVIEW_REQUEST_PATH,
+  LIGHT_RECONCILE_THROTTLE_MS,
   LINEAR_OAUTH_CANCELLED,
   LINEAR_OAUTH_PORT,
   LINEAR_OAUTH_REDIRECT,
@@ -34477,6 +34597,7 @@ init_outbound_watch();
   getRunScript,
   getSchedule,
   getSlackWorkspace,
+  getWorktreeDirtyStat,
   gh,
   ghHeadRef,
   ghRepoSelectArgs,
@@ -34554,6 +34675,7 @@ init_outbound_watch();
   isPrNotMergeableError,
   isPresentPlanToolName,
   isPrimaryCheckoutThread,
+  isSelfWrittenRecord,
   isSessionQuotaLimit,
   isSetupLastError,
   isShellToolName,