@sideboard-ai/core 0.1.212 → 0.1.213

package/dist/mcp/run-stdio.cjs

@@ -841,6 +841,7 @@ __export(thread_store_exports, {
   findThreadByRef: () => findThreadByRef,
   invalidateThreadListCache: () => invalidateThreadListCache,
   invalidateThreadRecord: () => invalidateThreadRecord,
+  isSelfWrittenRecord: () => isSelfWrittenRecord,
   isThreadRecordFile: () => isThreadRecordFile,
   listThreads: () => listThreads,
   normalizeThread: () => normalizeThread,
@@ -970,6 +971,7 @@ function forgetThread(id) {
   const cache = cacheForDir();
   cache.byId.delete(id);
   cache.mtimeMs.delete(id);
+  selfWriteMtimes.delete(id);
 }
 function invalidateThreadListCache() {
   listCache = null;
@@ -999,14 +1001,21 @@ function writeThread(thread, opts) {
   const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso() };
   (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify(next, null, 2), "utf8");
   (0, import_node_fs8.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 = (0, import_node_path9.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();
@@ -1072,7 +1081,7 @@ function findThreadByRef(ref) {
     (t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref
   ) ?? null;
 }
-var import_node_crypto2, import_node_fs8, import_node_path9, import_proper_lockfile, listCache;
+var import_node_crypto2, import_node_fs8, import_node_path9, import_proper_lockfile, listCache, selfWriteMtimes;
 var init_thread_store = __esm({
   "src/store/thread-store.ts"() {
     "use strict";
@@ -1084,6 +1093,7 @@ var init_thread_store = __esm({
     init_cursor_store();
     init_paths();
     listCache = null;
+    selfWriteMtimes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -14372,6 +14382,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_path38.join)(threadsDir(), `${threadId}.setup.log.json`);
 }
@@ -14382,20 +14415,21 @@ function setupLogKeyForWorktree(worktreePath) {
 function emptySetupLog() {
   return { ...EMPTY };
 }
-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_fs37.writeFileSync)(setupLogPath(threadId), `${JSON.stringify(snap)}
-`, "utf8");
+    (0, import_node_fs37.writeFileSync)(
+      setupLogPath(threadId),
+      `${JSON.stringify(materialize(mem))}
+`,
+      "utf8"
+    );
   } catch {
   }
 }
@@ -14406,7 +14440,7 @@ function schedulePersist(threadId) {
     setTimeout(() => {
       persistTimers.delete(threadId);
       persistNow(threadId);
-    }, 100)
+    }, PERSIST_DEBOUNCE_MS)
   );
 }
 function loadFromDisk(threadId) {
@@ -14424,51 +14458,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_crypto8, import_node_fs37, import_node_path38, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers;
+var import_node_crypto8, import_node_fs37, import_node_path38, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
 var init_setup_log = __esm({
   "src/store/setup-log.ts"() {
     "use strict";
@@ -14486,6 +14521,7 @@ var init_setup_log = __esm({
     MAX_SETUP_LOG_CHARS = 256e3;
     memory = /* @__PURE__ */ new Map();
     persistTimers = /* @__PURE__ */ new Map();
+    PERSIST_DEBOUNCE_MS = 500;
   }
 });
 
@@ -17526,6 +17562,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;
@@ -19175,6 +19243,29 @@ function writeWorktreeFile(worktreePath, relativePath, content) {
   (0, import_node_fs46.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,
@@ -20993,6 +21084,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,
@@ -21096,7 +21188,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";
@@ -21130,6 +21222,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();
@@ -21163,6 +21256,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();
@@ -21172,6 +21266,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
@@ -21257,6 +21353,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;
@@ -21289,6 +21399,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) {
@@ -21303,17 +21428,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
@@ -21547,7 +21661,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(
@@ -22403,17 +22517,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) {
@@ -22459,6 +22574,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));
@@ -22544,9 +22660,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);
@@ -22561,14 +22682,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)
           );
@@ -22578,24 +22703,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);
           }
@@ -22801,6 +22914,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");

package/dist/mcp/run-stdio.js

@@ -50,7 +50,7 @@ import {
   syncBoardPins,
   updateSchedule,
   waitForDetachedJob
-} from "../chunk-MS6HGW2H.js";
+} from "../chunk-D2IKXMF3.js";
 import "../chunk-JFOPOMK7.js";
 import "../chunk-YWI3IBP2.js";
 import {
@@ -61,12 +61,12 @@ import {
   materializeSystemCaBundle,
   sideboardMcpProfile,
   trustSystemCertificates
-} from "../chunk-IA5IPGZI.js";
+} from "../chunk-7MTVRNP4.js";
 import {
   GLOBAL_WORKSPACE_ID,
   isCloudCoordinatorThread,
   listWorkspaces
-} from "../chunk-WNVQJZ7P.js";
+} from "../chunk-KFD2OXCE.js";
 import "../chunk-3OHR73VK.js";
 import "../chunk-Y4MIXGPA.js";
 import "../chunk-YVE4PXCJ.js";
@@ -84,9 +84,9 @@ import {
   resolveListPrsOptions,
   resolveRepoRoot,
   warmGithubAgentAuth
-} from "../chunk-VPQXJYIW.js";
+} from "../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/{orchestrator-DW4HDWLA.js → orchestrator-MI7A5DQZ.js}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import {
+  LIGHT_RECONCILE_THROTTLE_MS,
   LIVE_TURN_SPAWN_GRACE_MS,
   Orchestrator,
   getOrchestrator,
@@ -9,17 +10,17 @@ import {
   resolveSendFollowUp,
   startOrchestration,
   waitForPidExit
-} from "./chunk-MS6HGW2H.js";
+} from "./chunk-D2IKXMF3.js";
 import "./chunk-JFOPOMK7.js";
 import "./chunk-YWI3IBP2.js";
-import "./chunk-IA5IPGZI.js";
-import "./chunk-WNVQJZ7P.js";
+import "./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 "./chunk-FNQNJOHY.js";
@@ -29,6 +30,7 @@ import "./chunk-KGZBYWZ3.js";
 import "./chunk-EQNRWDLN.js";
 import "./chunk-FJZWM2ON.js";
 export {
+  LIGHT_RECONCILE_THROTTLE_MS,
   LIVE_TURN_SPAWN_GRACE_MS,
   Orchestrator,
   getOrchestrator,

package/dist/{orchestrator-333M3JAU.js → orchestrator-WVZPTHBV.js}

@@ -1,4 +1,5 @@
 import {
+  LIGHT_RECONCILE_THROTTLE_MS,
   LIVE_TURN_SPAWN_GRACE_MS,
   Orchestrator,
   getOrchestrator,
@@ -7,11 +8,11 @@ import {
   resolveSendFollowUp,
   startOrchestration,
   waitForPidExit
-} from "./chunk-DINKOGEU.js";
+} from "./chunk-C32SBNA3.js";
 import "./chunk-DJU54RYW.js";
-import "./chunk-IRCAWYTN.js";
-import "./chunk-2PE6SZCM.js";
-import "./chunk-NRKDRQM3.js";
+import "./chunk-DFTVZEZY.js";
+import "./chunk-FNGXKY5W.js";
+import "./chunk-NI243N27.js";
 import "./chunk-6K64FJDD.js";
 import "./chunk-QQKDGPUI.js";
 import "./chunk-SALM35KD.js";
@@ -24,12 +25,13 @@ import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
 import "./chunk-4TYXWPAJ.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";
 import "./chunk-UFHNSFAS.js";
 export {
+  LIGHT_RECONCILE_THROTTLE_MS,
   LIVE_TURN_SPAWN_GRACE_MS,
   Orchestrator,
   getOrchestrator,

package/dist/{thread-store-MSMBQ3V4.js → thread-store-KDPPXJJ3.js}

@@ -7,6 +7,7 @@ import {
   findThreadByRef,
   invalidateThreadListCache,
   invalidateThreadRecord,
+  isSelfWrittenRecord,
   isThreadRecordFile,
   listThreads,
   normalizeThread,
@@ -16,7 +17,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-GHKFSBES.js";
+} from "./chunk-HY2GFZ5S.js";
 import "./chunk-X5B3OS5I.js";
 import "./chunk-KGZBYWZ3.js";
 import "./chunk-EQNRWDLN.js";
@@ -27,6 +28,7 @@ export {
   findThreadByRef,
   invalidateThreadListCache,
   invalidateThreadRecord,
+  isSelfWrittenRecord,
   isThreadRecordFile,
   listThreads,
   normalizeThread,

package/dist/{thread-store-4M6WETL6.js → thread-store-N6WQIWZ4.js}

@@ -5,6 +5,7 @@ import {
   findThreadByRef,
   invalidateThreadListCache,
   invalidateThreadRecord,
+  isSelfWrittenRecord,
   isThreadRecordFile,
   listThreads,
   normalizeThread,
@@ -14,7 +15,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-JJ3ONQ4Q.js";
+} from "./chunk-3IMSQNTS.js";
 import "./chunk-7J72QJOM.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-WFUDY6PC.js";
@@ -25,6 +26,7 @@ export {
   findThreadByRef,
   invalidateThreadListCache,
   invalidateThreadRecord,
+  isSelfWrittenRecord,
   isThreadRecordFile,
   listThreads,
   normalizeThread,

package/dist/{workspaces-VIUUE4RT.js → workspaces-KM7KTLVO.js}

@@ -6,10 +6,10 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-WNVQJZ7P.js";
-import "./chunk-VPQXJYIW.js";
+} from "./chunk-KFD2OXCE.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 "./chunk-FNQNJOHY.js";

package/dist/{workspaces-FRR6Y4BY.js → workspaces-R5LJCJRB.js}

@@ -4,15 +4,15 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-2PE6SZCM.js";
-import "./chunk-NRKDRQM3.js";
+} from "./chunk-FNGXKY5W.js";
+import "./chunk-NI243N27.js";
 import "./chunk-6K64FJDD.js";
 import "./chunk-QQKDGPUI.js";
 import "./chunk-L5CIEBLR.js";
 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";