@wrongstack/core 0.268.0 → 0.270.0

package/dist/coordination/index.js

@@ -172,8 +172,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat6 = await fsp6.stat(targetPath);
-      mode = stat6.mode & 511;
+      const stat7 = await fsp6.stat(targetPath);
+      mode = stat7.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -213,8 +213,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat6 = await fsp6.stat(lockPath);
-        if (Date.now() - stat6.mtimeMs > staleMs) {
+        const stat7 = await fsp6.stat(lockPath);
+        if (Date.now() - stat7.mtimeMs > staleMs) {
           await fsp6.unlink(lockPath);
           continue;
         }
@@ -545,8 +545,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat6 = await fsp6.stat(full);
-          if (stat6.isDirectory()) await walk(full, rest);
+          const stat7 = await fsp6.stat(full);
+          if (stat7.isDirectory()) await walk(full, rest);
         } catch {
         }
       }
@@ -563,8 +563,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat6 = await fsp6.stat(full);
-          if (stat6.isDirectory()) await walk(full, rest);
+          const stat7 = await fsp6.stat(full);
+          if (stat7.isDirectory()) await walk(full, rest);
         } catch {
         }
       }
@@ -636,7 +636,7 @@ function hasToolResult(msg) {
 }
 function toolUseIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "assistant") return ids;
+  if (msg?.role !== "assistant") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_use") ids.add(block.id);
   }
@@ -644,7 +644,7 @@ function toolUseIds(msg) {
 }
 function toolResultIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "user") return ids;
+  if (msg?.role !== "user") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_result") ids.add(block.tool_use_id);
   }
@@ -996,7 +996,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat6] = await Promise.all([
+        const [content, stat7] = await Promise.all([
           fsp6.readFile(filePath, "utf8"),
           fsp6.stat(filePath)
         ]);
@@ -1006,8 +1006,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat6.mtimeMs,
-          snapshotSizeBytes: stat6.size
+          snapshotMtimeMs: stat7.mtimeMs,
+          snapshotSizeBytes: stat7.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -1420,9 +1420,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat6 = await fsp6.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat6.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat6.size !== file.snapshotSizeBytes;
+        const stat7 = await fsp6.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat7.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat7.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -5432,7 +5432,7 @@ var SubagentBudget = class _SubagentBudget {
    */
   _busRequestDecision(entry) {
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
     return new Promise((resolve3) => {
@@ -8763,6 +8763,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * processes. When the limit is reached, the oldest entry is evicted.
    */
   _loadCache = /* @__PURE__ */ new Map();
+  _indexCache = null;
   static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
@@ -8924,15 +8925,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let errorMsg;
     let cacheHit = false;
     try {
-      let stat6;
-      try {
-        const s = await fsp6.stat(file);
-        stat6 = { mtimeMs: s.mtimeMs, size: s.size };
-      } catch (err) {
-        throw err;
-      }
+      const s = await fsp6.stat(file);
+      const stat7 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat6.mtimeMs && cached.size === stat6.size) {
+      if (cached && cached.mtimeMs === stat7.mtimeMs && cached.size === stat7.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -8960,7 +8956,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           this._loadCache.delete(oldest);
         }
       }
-      this._loadCache.set(id, { mtimeMs: stat6.mtimeMs, size: stat6.size, data });
+      this._loadCache.set(id, { mtimeMs: stat7.mtimeMs, size: stat7.size, data });
       return data;
     } catch (err) {
       outcome = "failure";
@@ -9021,6 +9017,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       const line = JSON.stringify(summary) + "\n";
       await fsp6.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
       this.indexAppendCount++;
       if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
         await this.compactIndex();
@@ -9035,6 +9032,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       const line = JSON.stringify({ action: "delete", id }) + "\n";
       await fsp6.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
       this.indexAppendCount++;
     } catch {
     }
@@ -9054,6 +9052,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
       await fsp6.writeFile(tmp, lines, "utf8");
       await fsp6.rename(tmp, this.indexFile);
+      this._indexCache = null;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
@@ -9067,10 +9066,22 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
+    let stat7;
+    try {
+      const s = await fsp6.stat(this.indexFile);
+      stat7 = { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      this._indexCache = null;
+      return [];
+    }
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat7.mtimeMs && this._indexCache.size === stat7.size) {
+      return [...this._indexCache.summaries];
+    }
     let raw;
     try {
       raw = await fsp6.readFile(this.indexFile, "utf8");
     } catch {
+      this._indexCache = null;
       return [];
     }
     const deleted = /* @__PURE__ */ new Set();
@@ -9090,7 +9101,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
       } catch {
       }
     }
-    return Array.from(seen.values());
+    const summaries = Array.from(seen.values());
+    this._indexCache = { ...stat7, summaries };
+    return [...summaries];
   }
   /**
    * Rebuild the index from disk by scanning all sessions and writing a
@@ -9104,6 +9117,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
     await fsp6.writeFile(tmp, lines, "utf8");
     await fsp6.rename(tmp, this.indexFile);
+    this._indexCache = null;
     return valid.length;
   }
   /** Recursively collect session IDs from date-shard subdirectories.
@@ -9144,8 +9158,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat6 = await fsp6.stat(full);
-      const summary = await this.summarize(id, stat6.mtime.toISOString());
+      const stat7 = await fsp6.stat(full);
+      const summary = await this.summarize(id, stat7.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -9227,8 +9241,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path5.join(dir, name);
       try {
-        const stat6 = await fsp6.stat(jsonlPath);
-        if (stat6.mtimeMs >= cutoff) return;
+        const stat7 = await fsp6.stat(jsonlPath);
+        if (stat7.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -9803,6 +9817,12 @@ var FileSessionWriter = class _FileSessionWriter {
       files
     });
   }
+  /**
+   * Truncate the session file to the checkpoint with the given promptIndex,
+   * removing all events that follow it. Uses a single-pass byte-offset scan
+   * so post-checkpoint content is never read or parsed — O(1) memory instead
+   * of O(N) JSON.parse calls over the full file.
+   */
   async truncateToCheckpoint(targetPromptIndex) {
     if (!this.filePath) return 0;
     if (this.flushTimer) {
@@ -9811,51 +9831,118 @@ var FileSessionWriter = class _FileSessionWriter {
     }
     await this.flushBuffer();
     await this.writeChain;
-    const raw = await fsp6.readFile(this.filePath, "utf8");
-    const lines = raw.split("\n");
-    const kept = [];
+    const CHUNK_SIZE = 65536;
+    let fd;
+    let fileOffset = 0;
+    let lineStartOffset = 0;
+    let checkpointByteOffset = -1;
     let removedCount = 0;
-    let targetCheckpointLine = -1;
-    let afterTarget = false;
-    for (let i = 0; i < lines.length; i++) {
-      const line = expectDefined(lines[i]);
-      if (!line.trim()) continue;
-      let event;
-      try {
-        event = JSON.parse(line);
-      } catch {
-        kept.push(line);
-        continue;
-      }
-      if (event.type === "checkpoint") {
-        if (event.promptIndex === targetPromptIndex) {
-          targetCheckpointLine = kept.length;
-          afterTarget = true;
-        } else if (event.promptIndex > targetPromptIndex) {
-          afterTarget = true;
+    let targetCheckpointSeen = false;
+    try {
+      fd = await fsp6.open(this.filePath, "r", 384);
+      while (true) {
+        const buf = Buffer.alloc(CHUNK_SIZE);
+        const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
+        if (bytesRead === 0) break;
+        let chunkPos = 0;
+        while (chunkPos < bytesRead) {
+          const idx = buf.indexOf("\n", chunkPos);
+          if (idx === -1) {
+            lineStartOffset = fileOffset + chunkPos;
+            break;
+          }
+          if (checkpointByteOffset !== -1) {
+            removedCount++;
+          } else {
+            const lineBytes = buf.subarray(chunkPos, idx);
+            const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
+            if (line.trim()) {
+              try {
+                const event = JSON.parse(line);
+                if (event.type === "checkpoint") {
+                  if (event.promptIndex === targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                    targetCheckpointSeen = true;
+                  } else if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                  }
+                } else if (targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                } else if (targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                }
+              } catch {
+              }
+            }
+          }
+          chunkPos = idx + 1;
+          lineStartOffset = fileOffset + chunkPos;
         }
-      }
-      if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
-        removedCount++;
-      } else if (event.promptIndex === void 0) {
-        if (!afterTarget || targetCheckpointLine === -1) {
-          kept.push(line);
-        } else {
-          removedCount++;
+        fileOffset += bytesRead;
+        if (chunkPos >= bytesRead) {
+          lineStartOffset = fileOffset;
         }
-      } else {
-        kept.push(line);
       }
+    } finally {
+      await fd?.close();
     }
-    const truncated = kept.join("\n");
+    if (checkpointByteOffset === -1) return 0;
+    await this.writeChain;
+    await this.handle.close();
     const tmpPath = `${this.filePath}.rewind.tmp`;
-    await fsp6.writeFile(tmpPath, truncated + "\n", "utf8");
+    const src = await fsp6.open(this.filePath, "r", 384);
     try {
-      await this.handle.close();
+      const statResult = await src.stat();
+      const totalSize = statResult.size;
+      const prefixBytes = checkpointByteOffset;
+      let newlineAfterCheckpoint = prefixBytes;
+      if (prefixBytes < totalSize) {
+        const probeBuf = Buffer.alloc(Math.min(CHUNK_SIZE, totalSize - prefixBytes));
+        const { bytesRead: probeRead } = await src.read(probeBuf, 0, probeBuf.length, prefixBytes);
+        if (probeRead > 0) {
+          const nl = probeBuf.indexOf("\n");
+          newlineAfterCheckpoint = nl !== -1 ? prefixBytes + nl + 1 : totalSize;
+        }
+      } else {
+        newlineAfterCheckpoint = totalSize;
+      }
+      const writeFd = await fsp6.open(tmpPath, "w", 384);
+      try {
+        let copied = 0;
+        let readOffset = 0;
+        while (readOffset < newlineAfterCheckpoint) {
+          const toCopy = Math.min(CHUNK_SIZE, newlineAfterCheckpoint - readOffset);
+          const copyBuf = Buffer.alloc(toCopy);
+          const { bytesRead: r } = await src.read(copyBuf, 0, toCopy, readOffset);
+          if (r === 0) break;
+          await writeFd.write(copyBuf, 0, r);
+          readOffset += r;
+          copied += r;
+        }
+        const raw = await fsp6.readFile(this.filePath);
+        const tail = raw.subarray(newlineAfterCheckpoint).toString("utf8");
+        for (const line of tail.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            JSON.parse(line);
+          } catch {
+            await writeFd.write(`${line}
+`, void 0, "utf8");
+          }
+        }
+      } finally {
+        await writeFd.close();
+      }
+      await src.close();
       await fsp6.rename(tmpPath, this.filePath);
       this.handle = await fsp6.open(this.filePath, "a", 384);
     } catch (err) {
       await fsp6.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp6.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
     await this.append({
@@ -10394,8 +10481,12 @@ function normalizeRecipient(to) {
 // src/coordination/mailbox.ts
 var MAILBOX_FILE = "_mailbox.jsonl";
 var LINE_SEPARATOR = "\n";
+var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
 var DefaultMailbox = class {
   filePath;
+  _messageCache = null;
+  _messageCacheMtime = -1;
+  _messageCacheSize = -1;
   constructor(sessionDir) {
     this.filePath = path5.join(sessionDir, MAILBOX_FILE);
   }
@@ -10425,12 +10516,13 @@ var DefaultMailbox = class {
     await fsp6.mkdir(path5.dirname(this.filePath), { recursive: true });
     await withFileLock(this.filePath, async () => {
       await fsp6.appendFile(this.filePath, line, "utf8");
+      this._pushToCache(msg);
     });
     return msg;
   }
   // ── Query ─────────────────────────────────────────────────────────────
   async query(q) {
-    const all = await this._readAll();
+    const all = await this._readAllCached();
     const limit = q.limit ?? 50;
     const order = q.minPriority !== void 0 ? { low: 0, normal: 1, high: 2 } : null;
     const minPriorityRank = order && q.minPriority !== void 0 ? order[q.minPriority] : 0;
@@ -10485,12 +10577,13 @@ var DefaultMailbox = class {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
         await fsp6.writeFile(this.filePath, serialized, "utf8");
       }
+      this._setMessageCache(all);
     });
     return updated;
   }
   // ── Agent statuses ────────────────────────────────────────────────────
   async getAgentStatuses() {
-    const all = await this._readAll();
+    const all = await this._readAllCached();
     const latest = /* @__PURE__ */ new Map();
     for (const m of all) {
       if (m.type !== "status") continue;
@@ -10526,16 +10619,20 @@ var DefaultMailbox = class {
   async heartbeat(_input) {
   }
   async unreadCount(forAgentId) {
-    const all = await this._readAll();
+    const all = await this._readAllCached();
     return all.filter(
       (m) => (m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed
     ).length;
   }
   async close() {
+    this._messageCache = null;
+    this._messageCacheMtime = -1;
+    this._messageCacheSize = -1;
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
       await fsp6.writeFile(this.filePath, "", "utf8");
+      this._setMessageCache([]);
     });
   }
   async purgeStale(opts) {
@@ -10543,13 +10640,14 @@ var DefaultMailbox = class {
     const INCOMPLETE_MAX_AGE_MS = opts?.incompleteMaxAgeMs ?? 6048e5;
     let completedPurged = 0;
     let incompletePurged = 0;
+    let remaining = 0;
     await withFileLock(this.filePath, async () => {
-      const all2 = await this._readAll();
+      const all = await this._readAll();
       const now = Date.now();
       const cutoffCompleted = now - COMPLETED_MAX_AGE_MS;
       const cutoffIncomplete = now - INCOMPLETE_MAX_AGE_MS;
       const kept = [];
-      for (const msg of all2) {
+      for (const msg of all) {
         const msgTime = new Date(msg.timestamp).getTime();
         const completedTime = msg.completedAt ? new Date(msg.completedAt).getTime() : 0;
         if (msg.completed && completedTime < cutoffCompleted) {
@@ -10562,17 +10660,18 @@ var DefaultMailbox = class {
         }
         kept.push(msg);
       }
-      if (kept.length < all2.length) {
+      remaining = kept.length;
+      if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
         await fsp6.writeFile(this.filePath, content, "utf8");
       }
+      this._setMessageCache(kept);
     });
-    const all = await this._readAll();
     return {
       completedPurged,
       incompletePurged,
       totalPurged: completedPurged + incompletePurged,
-      remaining: all.length
+      remaining
     };
   }
   // ── Client registry stubs (not applicable per-session) ─────────────────
@@ -10611,6 +10710,52 @@ var DefaultMailbox = class {
       throw err;
     }
   }
+  async _readAllCached() {
+    try {
+      const st = await fsp6.stat(this.filePath);
+      if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
+        return this._messageCache;
+      }
+      const all = await this._readAll();
+      this._setMessageCache(all, st.mtimeMs, st.size);
+      return all;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this._setMessageCache([], -1, -1);
+        return [];
+      }
+      throw err;
+    }
+  }
+  _setMessageCache(messages, mtime, size) {
+    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES) {
+      this._messageCache = null;
+      this._messageCacheMtime = -1;
+      this._messageCacheSize = -1;
+      return;
+    }
+    this._messageCache = messages;
+    if (mtime !== void 0 && size !== void 0) {
+      this._messageCacheMtime = mtime;
+      this._messageCacheSize = size;
+      return;
+    }
+    void fsp6.stat(this.filePath).then((st) => {
+      this._messageCacheMtime = st.mtimeMs;
+      this._messageCacheSize = st.size;
+    }).catch(() => {
+    });
+  }
+  _pushToCache(msg) {
+    if (this._messageCache === null) return;
+    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES) {
+      this._messageCache = null;
+      this._messageCacheMtime = -1;
+      this._messageCacheSize = -1;
+      return;
+    }
+    this._messageCache.push(msg);
+  }
 };
 var BrainMonitor = class {
   constructor(opts) {
@@ -10751,7 +10896,7 @@ var CLIENT_STALE_MS = 6e4;
 var HEARTBEAT_THROTTLE_MS = 5e3;
 var REGISTRY_CACHE_TTL_MS = 2e3;
 var LINE_SEPARATOR2 = "\n";
-var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
+var MESSAGE_CACHE_MAX_ENTRIES2 = 1e4;
 function resolveProjectDir(projectRoot, globalRoot) {
   return path5.join(globalRoot, "projects", projectSlug(projectRoot));
 }
@@ -11083,6 +11228,7 @@ var GlobalMailbox = class {
       name: input.name,
       source: input.source
     });
+    this.publishHqMailboxSnapshot();
   }
   async clientHeartbeat(input) {
     const last = this._lastClientHeartbeat.get(input.clientId) ?? 0;
@@ -11104,6 +11250,7 @@ var GlobalMailbox = class {
     this._events?.emitCustom("mailbox.client_heartbeat", {
       clientId: input.clientId
     });
+    this.publishHqMailboxSnapshot();
   }
   async getClientStatuses() {
     await this._ensureClientRegistry();
@@ -11250,7 +11397,7 @@ var GlobalMailbox = class {
    * read or wrote it under the file lock).
    */
   _setMessageCache(messages, mtime, size) {
-    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES) {
+    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES2) {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
@@ -11276,7 +11423,7 @@ var GlobalMailbox = class {
    */
   _pushToCache(msg) {
     if (this._messageCache === null) return;
-    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES) {
+    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES2) {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
@@ -11325,7 +11472,7 @@ var GlobalMailbox = class {
       obj[id] = agent;
     }
     const tmp = `${this.registryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp6.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
+    await fsp6.writeFile(tmp, JSON.stringify(obj), "utf8");
     await fsp6.rename(tmp, this.registryPath);
   }
   // ── Client registry internals ───────────────────────────────────────────
@@ -11370,7 +11517,7 @@ var GlobalMailbox = class {
       obj[id] = client;
     }
     const tmp = `${this.clientRegistryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp6.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
+    await fsp6.writeFile(tmp, JSON.stringify(obj), "utf8");
     await fsp6.rename(tmp, this.clientRegistryPath);
   }
 };
@@ -12563,7 +12710,7 @@ var TaskDAG = class {
     }
     for (const depId of node.dependents) {
       const dep = this.nodes.get(depId);
-      if (dep && dep.deps.every((d) => !this.nodes.has(d) || this.nodes.get(d).status === "done")) {
+      if (dep?.deps.every((d) => !this.nodes.has(d) || this.nodes.get(d).status === "done")) {
         this._transition(depId, "pending", "ready");
       }
     }
@@ -12825,7 +12972,7 @@ var ConsensusProtocol = class {
    */
   async initiateVote(changeId) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") {
+    if (change?.type !== "change") {
       throw new Error(`ConsensusProtocol: no change found with id "${changeId}"`);
     }
     await this.graph.update(changeId, { status: "proposed", votes: [] });
@@ -12838,7 +12985,7 @@ var ConsensusProtocol = class {
    */
   async castVote(changeId, voterId, value, rationale) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") {
+    if (change?.type !== "change") {
       throw new Error(`ConsensusProtocol: no change found for "${changeId}"`);
     }
     const voter = this.voters.get(voterId);
@@ -12892,7 +13039,7 @@ var ConsensusProtocol = class {
    */
   getStatus(changeId) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") return null;
+    if (change?.type !== "change") return null;
     const eligible = this._eligibleVoters(change);
     return this._resolve(changeId, change.votes, eligible);
   }
@@ -13095,7 +13242,7 @@ var ChangeManager = class {
    */
   async submitForReview(changeId) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") {
+    if (change?.type !== "change") {
       throw new Error(`ChangeManager: no change found "${changeId}"`);
     }
     if (change.status !== "proposed") {
@@ -13157,7 +13304,7 @@ var ChangeManager = class {
    */
   async proposeRollback(appliedChangeId, reason) {
     const original = this.graph.get(appliedChangeId);
-    if (!original || original.type !== "change") return null;
+    if (original?.type !== "change") return null;
     const rollbackFiles = original.files.map((f) => ({
       path: f.path,
       action: f.action === "create" ? "delete" : f.action === "delete" ? "create" : "modify"
@@ -13711,7 +13858,7 @@ var TaskAuctioneer = class {
    */
   async bid(taskId, agent, rationale) {
     const goal = this.graph.get(taskId);
-    if (!goal || goal.type !== "goal") return false;
+    if (goal?.type !== "goal") return false;
     if (goal.status !== "pending") return false;
     const currentCount = this._getAgentTaskCount(agent.agentId);
     if (currentCount >= this.maxTasksPerAgent) return false;
@@ -13760,7 +13907,7 @@ Score: ${score.toFixed(2)}`
    */
   async claim(taskId, agentId, agentName) {
     const goal = this.graph.get(taskId);
-    if (!goal || goal.type !== "goal") return false;
+    if (goal?.type !== "goal") return false;
     if (goal.status !== "pending") return false;
     this._cancelBidWindow(taskId);
     await this.graph.update(taskId, {