@sideboard-ai/core 0.1.211 → 0.1.213

package/dist/{chunk-ERNK7AWM.js → chunk-D2IKXMF3.js}

@@ -42,7 +42,7 @@ import {
   summarizeTurnStderr,
   toolDescription,
   turnFailChatText
-} from "./chunk-IA5IPGZI.js";
+} from "./chunk-7MTVRNP4.js";
 import {
   SLACK_REPLY_FORMATTING,
   addWorkspace,
@@ -65,7 +65,7 @@ import {
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   syncWorkspacesFromThreads
-} from "./chunk-WNVQJZ7P.js";
+} from "./chunk-KFD2OXCE.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -115,7 +115,7 @@ import {
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath,
   worktreeSlugForTicket
-} from "./chunk-VPQXJYIW.js";
+} from "./chunk-XYKVRRC2.js";
 import {
   ATTACHMENTS_DIR,
   DETACHED_JOBS_DIR,
@@ -133,7 +133,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-GHKFSBES.js";
+} from "./chunk-HY2GFZ5S.js";
 import {
   ensureWorktreeSideboardIgnored
 } from "./chunk-SYFVUF2C.js";
@@ -417,7 +417,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-NZO4PVFH.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-MI7A5DQZ.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -810,9 +810,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-RHABXQWB.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-KT3FRHZL.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-EHRDZ2ZU.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-LE2GQZ2X.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -2317,6 +2317,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`);
 }
@@ -2327,20 +2350,22 @@ function setupLogKeyForWorktree(worktreePath) {
 function emptySetupLog() {
   return { ...EMPTY };
 }
-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 {
   }
 }
@@ -2351,7 +2376,7 @@ function schedulePersist(threadId) {
     setTimeout(() => {
       persistTimers.delete(threadId);
       persistNow(threadId);
-    }, 100)
+    }, PERSIST_DEBOUNCE_MS)
   );
 }
 function loadFromDisk(threadId) {
@@ -2369,49 +2394,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
@@ -3903,6 +3929,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,
@@ -4314,7 +4367,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-VIUUE4RT.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-KM7KTLVO.js");
   await ensureWorkspace2(repoPath);
   const { ensureWorktreeSideboardIgnored: ensureWorktreeSideboardIgnored2 } = await import("./worktree-exclude-N5X5I422.js");
   await ensureWorktreeSideboardIgnored2(input.worktreePath);
@@ -5521,6 +5574,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,
@@ -6067,9 +6143,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 ?? []]);
@@ -6746,7 +6820,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-NZO4PVFH.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-MI7A5DQZ.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6877,6 +6951,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;
@@ -6891,6 +6966,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
@@ -6976,6 +7053,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;
@@ -7008,6 +7099,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) {
@@ -7022,17 +7128,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
@@ -7266,7 +7361,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(
@@ -7437,9 +7532,11 @@ var Orchestrator = class {
       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 });
@@ -7521,7 +7618,9 @@ var Orchestrator = class {
         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);
@@ -7569,7 +7668,6 @@ var Orchestrator = class {
       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, {
@@ -7585,7 +7683,7 @@ var Orchestrator = class {
       thread.worktreePath,
       gitPrompt,
       {
-        attachments: autoContinue ? [] : sentAttachments ?? thread.attachments
+        attachments: autoContinue ? [] : sentAttachments ?? []
       }
     );
     const slackInbound = /^(Slack DM|Slack @mention)(?:\n|$)/.test(
@@ -7639,10 +7737,7 @@ var Orchestrator = class {
       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);
@@ -8122,17 +8217,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) {
@@ -8178,6 +8274,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));
@@ -8263,9 +8360,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);
@@ -8280,14 +8382,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)
       );
@@ -8297,24 +8403,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);
       }
@@ -8520,6 +8614,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");
@@ -8968,7 +9067,7 @@ var Orchestrator = class {
     this.enforceHistoryRetention();
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-VIUUE4RT.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-KM7KTLVO.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -9022,7 +9121,7 @@ var Orchestrator = class {
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-3MEG62KB.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-VXRI7LYM.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -9132,7 +9231,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-3MEG62KB.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-VXRI7LYM.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({
@@ -9142,7 +9241,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-MSMBQ3V4.js");
+  const { updateThread: upd } = await import("./thread-store-KDPPXJJ3.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -9194,6 +9293,7 @@ export {
   waitForPidExit,
   resolveSendFollowUp,
   resolveOrchChildFollowUp,
+  LIGHT_RECONCILE_THROTTLE_MS,
   Orchestrator,
   getOrchestrator,
   startOrchestration

package/dist/{chunk-IRCAWYTN.js → chunk-DFTVZEZY.js}

@@ -1,12 +1,12 @@
 import {
   isOrchestratorThread
-} from "./chunk-2PE6SZCM.js";
+} from "./chunk-FNGXKY5W.js";
 import {
   codexUnattendedGitConfigArgs,
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv,
   resolveCodexGitWritableRoots
-} from "./chunk-NRKDRQM3.js";
+} from "./chunk-NI243N27.js";
 import {
   applyConnectedTeamToCli,
   brightsyMcpServerName,
@@ -1903,7 +1903,7 @@ var claudeAdapter = {
       );
     }
     const mode = permissionMode(thread);
-    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-NG2TBUI5.js");
+    const { isOrchestratorThread: isOrchestratorThread2 } = await import("./global-workspace-6P236KKG.js");
     const isOrchestrator = isOrchestratorThread2(thread);
     const injectedServers = await buildInjectedMcpServers({
       includeSideboard: true,

package/dist/{chunk-2PE6SZCM.js → chunk-FNGXKY5W.js}

@@ -5,7 +5,7 @@ import {
   resolveRepoRoot,
   takenSlugsFromThread,
   teamSlugFromName
-} from "./chunk-NRKDRQM3.js";
+} from "./chunk-NI243N27.js";
 import {
   ATTACHMENTS_DIR,
   attachmentsGitignoreBody
@@ -28,7 +28,7 @@ import {
   listThreads,
   updateThread,
   writeThread
-} from "./chunk-JJ3ONQ4Q.js";
+} from "./chunk-3IMSQNTS.js";
 import {
   appDataDir,
   globalAgentCwd,

package/dist/{chunk-GHKFSBES.js → chunk-HY2GFZ5S.js}

@@ -146,6 +146,7 @@ function forgetThread(id) {
   const cache = cacheForDir();
   cache.byId.delete(id);
   cache.mtimeMs.delete(id);
+  selfWriteMtimes.delete(id);
 }
 function invalidateThreadListCache() {
   listCache = null;
@@ -169,20 +170,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();
@@ -258,6 +267,7 @@ export {
   invalidateThreadRecord,
   readThread,
   writeThread,
+  isSelfWrittenRecord,
   isThreadRecordFile,
   listThreads,
   deleteThreadRecord,

package/dist/{chunk-WNVQJZ7P.js → chunk-KFD2OXCE.js}

@@ -7,7 +7,7 @@ import {
   resolveRepoRoot,
   takenSlugsFromThread,
   teamSlugFromName
-} from "./chunk-VPQXJYIW.js";
+} from "./chunk-XYKVRRC2.js";
 import {
   ATTACHMENTS_DIR,
   attachmentsGitignoreBody
@@ -17,7 +17,7 @@ import {
   listThreads,
   updateThread,
   writeThread
-} from "./chunk-GHKFSBES.js";
+} from "./chunk-HY2GFZ5S.js";
 import {
   assertOrchestratorCapableAgent,
   formatAccountProfilePlaybookLine,