@wrongstack/core 0.301.0 → 0.302.2

package/dist/coordination/index.js

@@ -224,7 +224,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve16, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -243,7 +243,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve14,
+        resolve: resolve16,
         reject,
         timer
       });
@@ -592,13 +592,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve16) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve14(d);
+        resolve16(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -6265,13 +6265,13 @@ var BrainDecisionQueue = class {
       options: request.options,
       rationale: "Decision escalated to human authority."
     };
-    const pending = new Promise((resolve14) => {
-      const entry = { request, resolve: resolve14 };
+    const pending = new Promise((resolve16) => {
+      const entry = { request, resolve: resolve16 };
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
           markDecisionTier(request, "terminal");
-          resolve14(
+          resolve16(
             this.opts.onTimeout?.(request) ?? {
               type: "deny",
               reason: "Brain human decision timed out."
@@ -7050,26 +7050,26 @@ var BrainMonitor = class {
   trackFileChurn(toolName, ok, input) {
     if (!this.signals.fileChurn) return;
     if (!ok || !this.fileEditTools.has(toolName.toLowerCase())) return;
-    const path34 = editedPath(input);
-    if (!path34) return;
+    const path36 = editedPath(input);
+    if (!path36) return;
     const now = Date.now();
-    const stamps = (this.editTimestamps.get(path34) ?? []).filter(
+    const stamps = (this.editTimestamps.get(path36) ?? []).filter(
       (t) => now - t <= this.fileChurnWindowMs
     );
     stamps.push(now);
     if (stamps.length >= this.fileChurnThreshold) {
-      this.editTimestamps.delete(path34);
+      this.editTimestamps.delete(path36);
       void this.engage("file_churn", {
-        question: `The file "${path34}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
+        question: `The file "${path36}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
         context: [
-          `File: ${path34}`,
+          `File: ${path36}`,
           `Edits in window: ${stamps.length}`,
           `Window: ${Math.round(this.fileChurnWindowMs / 1e3)}s`
         ].join("\n")
       });
       return;
     }
-    this.editTimestamps.set(path34, stamps);
+    this.editTimestamps.set(path36, stamps);
   }
   async engage(kind, input) {
     const last = this.lastEngagedAt.get(kind) ?? 0;
@@ -8998,7 +8998,7 @@ async function gitOtherWorktrees(cwd, signal) {
   return branches.slice(1);
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve16, reject) => {
     let stdout = "";
     let stderr = "";
     const child = spawn("git", args, {
@@ -9017,7 +9017,7 @@ function runGit(args, cwd, signal) {
     });
     child.on("error", (err) => reject(err));
     child.on("close", (code) => {
-      if (code === 0) resolve14(stdout);
+      if (code === 0) resolve16(stdout);
       else reject(new Error(stderr || `git ${args[0]} exited ${code}`));
     });
   });
@@ -9516,7 +9516,7 @@ function createDelegateTool(opts) {
   };
 }
 async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve16) => {
     let settled = false;
     let timer;
     let offAbort = () => {
@@ -9529,7 +9529,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
       offIter();
       offProgress();
       offAbort();
-      resolve14(value);
+      resolve16(value);
     };
     const arm = () => {
       if (timer) clearTimeout(timer);
@@ -9894,7 +9894,7 @@ function attachDepWatcherBridge(opts) {
 }
 
 // src/coordination/director.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 import * as fsp19 from "node:fs/promises";
 
 // src/core/instruction-template.ts
@@ -10746,10 +10746,10 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve16) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (result) => resolve14({
+        resolve: (result) => resolve16({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         })
@@ -10757,7 +10757,7 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve14({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve16({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -10875,11 +10875,11 @@ ${JSON.stringify(result.result, null, 2)}
         this.makeStoppedResult(taskId, "director", `Unknown task id "${taskId}" \u2014 never assigned`)
       );
     }
-    let resolve14;
+    let resolve16;
     const promise = new Promise((done) => {
-      resolve14 = done;
+      resolve16 = done;
     });
-    this.taskWaiters.set(taskId, { promise, resolve: resolve14 });
+    this.taskWaiters.set(taskId, { promise, resolve: resolve16 });
     return promise;
   }
   recordAssignment(task) {
@@ -12769,11 +12769,394 @@ function rosterSummaryFromConfigs(roster) {
 
 // src/coordination/director-session.ts
 import * as fsp18 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path26 from "node:path";
 
 // src/storage/session-store.ts
+import { randomUUID as randomUUID12 } from "node:crypto";
 import * as fsp17 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as path25 from "node:path";
+
+// src/session-catalog/client.ts
+import { spawn as spawn2 } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as net from "node:net";
+import * as path15 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// src/session-catalog/endpoint.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as os2 from "node:os";
+import * as path14 from "node:path";
+
+// src/session-catalog/protocol.ts
+var SESSION_CATALOG_PROTOCOL_VERSION = 1;
+var SESSION_CATALOG_MAX_FRAME_CHARS = 4 * 1024 * 1024;
+function encodeSessionCatalogMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+
+// src/session-catalog/endpoint.ts
+var SESSION_CATALOG_METADATA_FILE = ".session-catalog-server.json";
+function normalizedPath(value) {
+  const resolved = path14.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function sessionCatalogProjectServerKey(projectDir) {
+  return createHash2("sha256").update(normalizedPath(projectDir)).digest("hex").slice(0, 24);
+}
+function sessionCatalogProjectServerEndpoint(projectDir) {
+  const key = sessionCatalogProjectServerKey(projectDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-session-catalog-v${SESSION_CATALOG_PROTOCOL_VERSION}-${key}`;
+  }
+  return path14.join(os2.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
+}
+function sessionCatalogProjectServerMetadataPath(projectDir) {
+  return path14.join(projectDir, SESSION_CATALOG_METADATA_FILE);
+}
+
+// src/session-catalog/client.ts
+var CONNECT_TIMEOUT_MS = 750;
+var START_TIMEOUT_MS = 1e4;
+var CALL_TIMEOUT_MS = 3e4;
+var MAX_PENDING_REQUESTS = 1024;
+var MAX_EVENT_LISTENERS = 64;
+function locateServer(moduleUrl, exists) {
+  for (const candidate of [
+    "./project-server.js",
+    "../session-catalog/project-server.js",
+    "./session-catalog/project-server.js",
+    "../../dist/session-catalog/project-server.js"
+  ]) {
+    try {
+      const url = new URL(candidate, moduleUrl);
+      if (url.protocol === "file:" && exists(fileURLToPath3(url))) return url;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveSessionCatalogDaemonAvailability(moduleUrl = import.meta.url, exists = fs3.existsSync) {
+  if (process.env["WRONGSTACK_SESSION_CATALOG_INLINE"] || process.env["WRONGSTACK_SESSION_CATALOG_SERVER"] === "0")
+    return { kind: "inline-requested" };
+  const url = locateServer(moduleUrl, exists);
+  return url ? { kind: "available", url } : { kind: "missing-build" };
+}
+function resolveSessionCatalogProjectServerUrl(moduleUrl = import.meta.url, exists = fs3.existsSync) {
+  const availability = resolveSessionCatalogDaemonAvailability(moduleUrl, exists);
+  return availability.kind === "available" ? availability.url : null;
+}
+function normalize2(value) {
+  const resolved = path15.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function delay(ms) {
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
+}
+var SessionCatalogProjectClient = class {
+  constructor(options) {
+    this.options = options;
+    this.endpoint = sessionCatalogProjectServerEndpoint(options.projectDir);
+  }
+  options;
+  endpoint;
+  socket = null;
+  info = null;
+  buffer = "";
+  connecting = null;
+  connectResolve = null;
+  connectReject = null;
+  authToken;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Set();
+  reconnectTimer;
+  explicitlyClosed = false;
+  async call(op, args, options = {}) {
+    await this.ensureConnected(true);
+    return this.request({ type: "request", op, args }, options.timeoutMs ?? CALL_TIMEOUT_MS);
+  }
+  /**
+   * Call an already-running project daemon without starting one.
+   *
+   * Cross-project discovery must use this path: observing another project is
+   * never sufficient authority to wake that project's IPC owner.
+   */
+  async callExisting(op, args, options = {}) {
+    await this.ensureConnected(false);
+    return this.request({ type: "request", op, args }, options.timeoutMs ?? CALL_TIMEOUT_MS);
+  }
+  ping() {
+    return this.call("ping", {}, { timeoutMs: 3e3 });
+  }
+  async subscribe(listener) {
+    if (!this.eventListeners.has(listener) && this.eventListeners.size >= MAX_EVENT_LISTENERS) {
+      throw new Error(`Session Catalog listener limit reached (${MAX_EVENT_LISTENERS})`);
+    }
+    this.explicitlyClosed = false;
+    this.eventListeners.add(listener);
+    try {
+      await this.call("subscribe", {});
+    } catch (error) {
+      this.eventListeners.delete(listener);
+      throw error;
+    }
+    return async () => {
+      this.eventListeners.delete(listener);
+      if (this.eventListeners.size === 0)
+        await this.callExisting("unsubscribe", {}).catch(() => void 0);
+    };
+  }
+  async shutdown(reason) {
+    try {
+      await this.ensureConnected(false);
+    } catch {
+      return { stopped: false };
+    }
+    const result = await this.request({ type: "shutdown", ...reason !== void 0 ? { reason } : {} }, 5e3).catch(
+      () => ({ stopped: false })
+    );
+    if (result.stopped) {
+      const metadataPath = sessionCatalogProjectServerMetadataPath(this.options.projectDir);
+      const deadline = Date.now() + 5e3;
+      while (fs3.existsSync(metadataPath) && Date.now() < deadline) await delay(20);
+      if (result.pid && result.pid !== process.pid) {
+        while (Date.now() < deadline) {
+          try {
+            process.kill(result.pid, 0);
+            await delay(20);
+          } catch {
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async close() {
+    this.explicitlyClosed = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = void 0;
+    const socket = this.socket;
+    this.socket = null;
+    this.info = null;
+    if (socket && !socket.destroyed)
+      await new Promise((resolve16) => {
+        socket.once("close", resolve16);
+        socket.end();
+      });
+  }
+  async ensureConnected(spawnIfMissing) {
+    if (this.socket && !this.socket.destroyed && this.info) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = this.connectWithElection(spawnIfMissing).finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+  async connectWithElection(spawnIfMissing) {
+    const deadline = Date.now() + (spawnIfMissing ? START_TIMEOUT_MS : CONNECT_TIMEOUT_MS);
+    let spawned = false;
+    let lastError = new Error("Session Catalog project server unavailable");
+    while (Date.now() < deadline) {
+      try {
+        await this.connectOnce();
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      if (!spawnIfMissing) break;
+      if (!spawned) {
+        this.spawnDetached();
+        spawned = true;
+      }
+      await delay(75);
+    }
+    throw lastError;
+  }
+  connectOnce() {
+    this.socket?.destroy();
+    this.socket = null;
+    this.info = null;
+    this.authToken = void 0;
+    this.buffer = "";
+    return new Promise((resolve16, reject) => {
+      const socket = net.createConnection(this.endpoint);
+      this.socket = socket;
+      socket.setEncoding("utf8");
+      const timer = setTimeout(() => {
+        reject(new Error("Session Catalog handshake timed out"));
+        socket.destroy();
+      }, CONNECT_TIMEOUT_MS);
+      timer.unref?.();
+      this.connectResolve = () => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        resolve16();
+      };
+      this.connectReject = (error) => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        reject(error);
+      };
+      socket.on("data", (chunk) => this.onData(socket, chunk));
+      socket.on("error", (error) => {
+        if (!this.info) this.connectReject?.(error);
+      });
+      socket.on("close", () => this.onClose(socket));
+    });
+  }
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const parsed = JSON.parse(
+          fs3.readFileSync(sessionCatalogProjectServerMetadataPath(this.options.projectDir), "utf8")
+        );
+        if (typeof parsed.authToken === "string" && parsed.authToken)
+          this.authToken = parsed.authToken;
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
+  request(message, timeoutMs) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed)
+      return Promise.reject(new Error("Session Catalog connection is unavailable"));
+    const id = this.nextId++;
+    if (this.pending.size >= MAX_PENDING_REQUESTS) {
+      return Promise.reject(
+        new Error(`Session Catalog pending request limit reached (${MAX_PENDING_REQUESTS})`)
+      );
+    }
+    const encoded = encodeSessionCatalogMessage({
+      ...message,
+      id,
+      authToken: this.currentAuthToken()
+    });
+    if (encoded.length > SESSION_CATALOG_MAX_FRAME_CHARS)
+      return Promise.reject(new Error("Session Catalog request exceeded frame limit"));
+    return new Promise((resolve16, reject) => {
+      const timer = setTimeout(() => {
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        this.pending.delete(id);
+        pending.reject(
+          new Error(
+            `Session Catalog ${message.type === "request" ? message.op : message.type} timed out`
+          )
+        );
+      }, timeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { resolve: resolve16, reject, timer });
+      socket.write(encoded);
+    });
+  }
+  onData(socket, chunk) {
+    if (socket !== this.socket) return;
+    this.buffer += chunk;
+    if (this.buffer.length > SESSION_CATALOG_MAX_FRAME_CHARS) {
+      socket.destroy(new Error("Session Catalog response exceeded frame limit"));
+      return;
+    }
+    while (true) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) return;
+      const line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line) continue;
+      try {
+        this.onMessage(JSON.parse(line));
+      } catch {
+        socket.destroy(new Error("Invalid Session Catalog response"));
+        return;
+      }
+    }
+  }
+  onMessage(message) {
+    if (message.type === "hello") {
+      if (message.protocolVersion !== SESSION_CATALOG_PROTOCOL_VERSION) {
+        this.connectReject?.(
+          new Error(
+            `Session Catalog protocol mismatch: client=${SESSION_CATALOG_PROTOCOL_VERSION}, server=${message.protocolVersion}`
+          )
+        );
+        this.socket?.destroy();
+        return;
+      }
+      if (normalize2(message.projectDir) !== normalize2(this.options.projectDir) || normalize2(message.projectRoot) !== normalize2(this.options.projectRoot)) {
+        this.connectReject?.(new Error("Session Catalog project identity mismatch"));
+        this.socket?.destroy();
+        return;
+      }
+      this.info = message;
+      this.connectResolve?.();
+      return;
+    }
+    if (message.type === "event") {
+      for (const listener of this.eventListeners) {
+        try {
+          listener(message.event);
+        } catch {
+        }
+      }
+      return;
+    }
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.ok) pending.resolve(message.result);
+    else {
+      const error = new Error(message.error);
+      if (message.errorName) error.name = message.errorName;
+      pending.reject(error);
+    }
+  }
+  onClose(socket) {
+    if (socket !== this.socket) return;
+    this.socket = null;
+    this.info = null;
+    this.authToken = void 0;
+    const error = new Error("Session Catalog connection closed");
+    this.connectReject?.(error);
+    this.connectResolve = null;
+    this.connectReject = null;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    this.scheduleSubscriptionReconnect();
+  }
+  scheduleSubscriptionReconnect() {
+    if (this.explicitlyClosed || this.eventListeners.size === 0 || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      void this.call("subscribe", {}).catch(() => this.scheduleSubscriptionReconnect());
+    }, 250);
+    this.reconnectTimer.unref?.();
+  }
+  spawnDetached() {
+    const url = resolveSessionCatalogProjectServerUrl();
+    if (!url) throw new Error("Built Session Catalog project server is unavailable");
+    const child = spawn2(
+      process.execPath,
+      [
+        fileURLToPath3(url),
+        "--project-dir",
+        this.options.projectDir,
+        "--project-root",
+        this.options.projectRoot
+      ],
+      { detached: true, stdio: "ignore", windowsHide: true, env: process.env }
+    );
+    child.unref();
+  }
+};
 
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
@@ -12910,14 +13293,14 @@ function ulid(seedTime = Date.now()) {
 }
 
 // src/utils/session-scoped-path.ts
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path14.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path14.relative(path14.resolve(dir), resolved);
-  if (rel.startsWith("..") || path14.isAbsolute(rel)) {
+  const resolved = path16.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path16.relative(path16.resolve(dir), resolved);
+  if (rel.startsWith("..") || path16.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -12939,7 +13322,7 @@ function truncate3(s, max) {
 // src/storage/file-session-writer.ts
 import { closeSync, createReadStream as createReadStream2, fsyncSync, openSync, writeSync } from "node:fs";
 import * as fsp7 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as path17 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // src/storage/session-workspace-checkpoints.ts
@@ -13205,7 +13588,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path15.join(opts.dir, `${path15.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path17.join(opts.dir, `${path17.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.checkpointCas = opts.checkpointCas;
@@ -14094,10 +14477,10 @@ var FileSessionWriter = class _FileSessionWriter {
 };
 
 // src/storage/session-checkpoint-cas.ts
-import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash2, randomUUID as randomUUID11 } from "node:crypto";
+import { spawn as spawn3 } from "node:child_process";
+import { createHash as createHash3, randomUUID as randomUUID11 } from "node:crypto";
 import * as fsp8 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as path18 from "node:path";
 
 // src/storage/storage-concurrency.ts
 async function mapWithConcurrency(items, concurrency, mapper) {
@@ -14125,16 +14508,16 @@ var MAX_GIT_OUTPUT = 16 * 1024 * 1024;
 var MAX_BLOB_BYTES = 64 * 1024 * 1024;
 var MAX_CHECKPOINT_BYTES = 512 * 1024 * 1024;
 function sha256(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash3("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative4 = path16.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path16.isAbsolute(relative4);
+  const relative4 = path18.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path18.isAbsolute(relative4);
 }
 function normalizeRelative(input) {
-  if (!input || path16.isAbsolute(input)) return null;
+  if (!input || path18.isAbsolute(input)) return null;
   const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
-  const resolved = path16.posix.normalize(normalized);
+  const resolved = path18.posix.normalize(normalized);
   if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
   return resolved;
 }
@@ -14149,8 +14532,8 @@ var SessionCheckpointCas = class {
   projectRoot;
   runGit;
   constructor(opts) {
-    this.rootDir = path16.resolve(opts.rootDir);
-    this.projectRoot = path16.resolve(opts.projectRoot);
+    this.rootDir = path18.resolve(opts.rootDir);
+    this.projectRoot = path18.resolve(opts.projectRoot);
     this.runGit = opts.runGit ?? defaultRunGit;
   }
   async capture(_sessionId, _promptIndex) {
@@ -14175,7 +14558,7 @@ var SessionCheckpointCas = class {
       relativePaths,
       CAPTURE_CONCURRENCY,
       async (relative4) => {
-        const absolute = path16.resolve(this.projectRoot, ...relative4.split("/"));
+        const absolute = path18.resolve(this.projectRoot, ...relative4.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
           unresolved.push({ path: relative4, reason: "path escapes project root" });
           return null;
@@ -14184,8 +14567,8 @@ var SessionCheckpointCas = class {
           const stat10 = await fsp8.lstat(absolute);
           if (stat10.isSymbolicLink()) {
             const linkTarget = await fsp8.readlink(absolute);
-            const resolvedLink = path16.resolve(path16.dirname(absolute), linkTarget);
-            if (path16.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+            const resolvedLink = path18.resolve(path18.dirname(absolute), linkTarget);
+            if (path18.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
                 path: relative4,
                 reason: "symlink target escapes project root"
@@ -14247,7 +14630,7 @@ var SessionCheckpointCas = class {
     };
   }
   async materialize(checkpoint, targetRoot) {
-    const target = path16.resolve(targetRoot);
+    const target = path18.resolve(targetRoot);
     if (target === this.projectRoot) {
       throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
     }
@@ -14287,10 +14670,10 @@ var SessionCheckpointCas = class {
       try {
         const output = await this.safeOutputPath(target, realTarget, entry.path);
         if (entry.state === "symlink") {
-          if (path16.isAbsolute(entry.linkTarget)) {
+          if (path18.isAbsolute(entry.linkTarget)) {
             throw new Error("absolute symlink target refused");
           }
-          const resolvedLink = path16.resolve(path16.dirname(output), entry.linkTarget);
+          const resolvedLink = path18.resolve(path18.dirname(output), entry.linkTarget);
           if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
         }
         prepared.push({
@@ -14318,7 +14701,7 @@ var SessionCheckpointCas = class {
           await fsp8.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
-          await fsp8.mkdir(path16.dirname(output), { recursive: true });
+          await fsp8.mkdir(path18.dirname(output), { recursive: true });
           await fsp8.symlink(entry.linkTarget, output);
           writtenFiles.push(entry.path);
           continue;
@@ -14335,15 +14718,15 @@ var SessionCheckpointCas = class {
   }
   objectPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
-    return path16.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+    return path18.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
   }
   manifestPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
-    return path16.join(this.rootDir, "manifests", `${hash}.json`);
+    return path18.join(this.rootDir, "manifests", `${hash}.json`);
   }
   async putBlob(hash, content) {
     const target = this.objectPath(hash);
-    await fsp8.mkdir(path16.dirname(target), { recursive: true });
+    await fsp8.mkdir(path18.dirname(target), { recursive: true });
     try {
       const existing = await fsp8.readFile(target);
       if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
@@ -14351,9 +14734,9 @@ var SessionCheckpointCas = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    const temp = path16.join(
-      path16.dirname(target),
-      `.${path16.basename(target)}.${process.pid}.${randomUUID11()}.tmp`
+    const temp = path18.join(
+      path18.dirname(target),
+      `.${path18.basename(target)}.${process.pid}.${randomUUID11()}.tmp`
     );
     let handle;
     try {
@@ -14414,7 +14797,7 @@ var SessionCheckpointCas = class {
   async safeOutputPath(target, realTarget, relative4) {
     const normalized = normalizeRelative(relative4);
     if (!normalized) throw new Error("invalid relative path");
-    const output = path16.resolve(target, ...normalized.split("/"));
+    const output = path18.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
     let probe = output;
     for (; ; ) {
@@ -14424,7 +14807,7 @@ var SessionCheckpointCas = class {
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
-        const parent = path16.dirname(probe);
+        const parent = path18.dirname(probe);
         if (parent === probe) throw err;
         probe = parent;
       }
@@ -14432,14 +14815,14 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve16) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
     let stderrBytes = 0;
     let stdoutTruncated = false;
     let stderrTruncated = false;
-    const child = spawn2("git", args, {
+    const child = spawn3("git", args, {
       cwd,
       env: buildChildEnv(),
       stdio: ["ignore", "pipe", "pipe"],
@@ -14475,8 +14858,8 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve14(result(1, err.message)));
-    child.on("close", (code) => resolve14(result(code ?? 1)));
+    child.on("error", (err) => resolve16(result(1, err.message)));
+    child.on("close", (code) => resolve16(result(code ?? 1)));
   });
 }
 
@@ -14488,13 +14871,13 @@ function generateSessionId(startedAt, _model) {
 }
 
 // src/storage/session-id-resolver.ts
-import * as path17 from "node:path";
+import * as path19 from "node:path";
 function resolveSessionId(query, candidateIds) {
   const normalized = query.trim();
   if (!normalized) return { status: "missing", query: normalized };
   const uniqueIds = [...new Set(candidateIds)];
   if (uniqueIds.includes(normalized)) return { status: "resolved", id: normalized };
-  const leaf = (id) => path17.posix.basename(id.replace(/\\/g, "/"));
+  const leaf = (id) => path19.posix.basename(id.replace(/\\/g, "/"));
   const exactLeafMatches = uniqueIds.filter((id) => leaf(id) === normalized);
   if (exactLeafMatches.length === 1) {
     return { status: "resolved", id: exactLeafMatches[0] };
@@ -14543,15 +14926,15 @@ function scrubPersistedSessionSummary(summary, scrubber2) {
 }
 
 // src/storage/session-resume-validation.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import * as fsp9 from "node:fs/promises";
-import * as path18 from "node:path";
+import * as path20 from "node:path";
 var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative4 = path18.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path18.isAbsolute(relative4);
+  const relative4 = path20.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path20.isAbsolute(relative4);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -14562,7 +14945,7 @@ function latestObservations(events, projectRoot) {
     if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
       continue;
     }
-    const normalized = path18.resolve(projectRoot, event.path);
+    const normalized = path20.resolve(projectRoot, event.path);
     latest.set(normalized, {
       path: normalized,
       hash: event.hash.toLowerCase(),
@@ -14611,7 +14994,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
       };
     }
     const content = await fsp9.readFile(realFile, "utf8");
-    const actualHash = createHash3("sha256").update(content, "utf8").digest("hex");
+    const actualHash = createHash4("sha256").update(content, "utf8").digest("hex");
     if (actualHash === observation.hash) return null;
     return { ...base, status: "modified", actualHash };
   } catch (err) {
@@ -14620,7 +15003,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
 }
 async function validateResumeFileObservations(events, projectRoot) {
-  const lexicalRoot = path18.resolve(projectRoot);
+  const lexicalRoot = path20.resolve(projectRoot);
   const realRoot = await fsp9.realpath(lexicalRoot).catch(() => lexicalRoot);
   const observations = latestObservations(events, lexicalRoot);
   const results = await mapWithConcurrency(
@@ -14636,9 +15019,9 @@ async function validateResumeFileObservations(events, projectRoot) {
 }
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
-  const root = path18.resolve(projectRoot);
+  const root = path20.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative4 = path18.relative(root, entry.path);
+    const relative4 = path20.relative(root, entry.path);
     const display = isInside2(root, entry.path) ? relative4 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
@@ -14663,22 +15046,22 @@ function formatInterruptedToolNotice(pendingToolUseCount) {
 
 // src/storage/session-store/delete-session-artifacts.ts
 import * as fsp10 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path22 from "node:path";
 
 // src/storage/session-store/paths.ts
-import * as path19 from "node:path";
+import * as path21 from "node:path";
 function sessionPath(storeDir, id, ext) {
   return sessionScopedPath(storeDir, id, ext);
 }
 function shardManifestPath(storeDir, shardKey) {
-  return shardKey ? path19.join(storeDir, shardKey, "_manifest.json") : path19.join(storeDir, "_manifest.json");
+  return shardKey ? path21.join(storeDir, shardKey, "_manifest.json") : path21.join(storeDir, "_manifest.json");
 }
 function shardKeyForSessionId(id) {
-  const dirName = path19.dirname(id);
+  const dirName = path21.dirname(id);
   return dirName === "." ? "" : dirName;
 }
 async function ensureShardDir(storeDir, id) {
-  const dirPath = path19.dirname(sessionScopedPath(storeDir, id, ""));
+  const dirPath = path21.dirname(sessionScopedPath(storeDir, id, ""));
   await ensureDir(dirPath);
   return dirPath;
 }
@@ -14689,9 +15072,9 @@ async function deleteSessionArtifacts({
   id,
   jsonlPath
 }) {
-  const shardDir = path20.dirname(jsonlPath);
-  const base = path20.basename(id);
-  const sessDir = path20.join(shardDir, base);
+  const shardDir = path22.dirname(jsonlPath);
+  const base = path22.basename(id);
+  const sessDir = path22.join(shardDir, base);
   const deletions = [
     fsp10.unlink(jsonlPath),
     fsp10.unlink(sessionPath(rootDir, id, ".summary.json")),
@@ -14750,7 +15133,7 @@ function isSessionJsonlFileName(name) {
 
 // src/storage/session-store/directory-session-files.ts
 import * as fsp11 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as path23 from "node:path";
 function sessionIdForFile(prefix, name) {
   const base = name.replace(/\.jsonl$/, "");
   return prefix ? `${prefix}/${base}` : base;
@@ -14772,12 +15155,12 @@ async function collectSessionFiles(dir, prefix = "", depth = 0) {
     if (entry.isDirectory()) {
       dirEntries.push(entry);
     } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
-      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path21.join(dir, entry.name) });
+      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path23.join(dir, entry.name) });
     }
   }
   const childFileArrays = await Promise.all(
     dirEntries.map(
-      (entry) => collectSessionFiles(path21.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+      (entry) => collectSessionFiles(path23.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
     )
   );
   return [...childFileArrays.flat(), ...files];
@@ -14801,7 +15184,7 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
   }
   const childIdArrays = await Promise.all(
     dirEntries.map(
-      (entry) => collectSessionIds(path21.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+      (entry) => collectSessionIds(path23.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
     )
   );
   return [...childIdArrays.flat(), ...fileIds];
@@ -14843,7 +15226,7 @@ function emitSessionStoreError(events, sessionId, filePath, operation, error, re
 }
 
 // src/storage/session-store/fork-session.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // src/storage/session-store/replay.ts
 function isReplayableMessage(value) {
@@ -14915,7 +15298,7 @@ async function forkSession(host, id, opts = {}) {
   }
   const parentPrefix = parent.events.slice(0, boundary + 1);
   const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
-  const checkpointHash = createHash4("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
+  const checkpointHash = createHash5("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
   const inherited = parentPrefix.filter(inheritsIntoFork);
   const writer = await host.create({
     id: "",
@@ -15258,6 +15641,16 @@ function replaySessionEvent(params) {
     } else {
       emitDamaged(params, "Ignored malformed messages_replaced event");
     }
+  } else if (ev.type === "messages_dropped" && ev.version === 1) {
+    if (exactJournalActive && Number.isInteger(ev.count) && ev.count > 0) {
+      messages.splice(0, Math.min(ev.count, messages.length));
+      openToolUses.clear();
+      for (const current of messages) trackMessageToolState(current, openToolUses);
+    } else if (!exactJournalActive) {
+      emitDamaged(params, "Ignored messages_dropped event outside the exact journal");
+    } else {
+      emitDamaged(params, `Ignored malformed messages_dropped event (count ${String(ev.count)})`);
+    }
   } else if (ev.type === "context_snapshot") {
     if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
       emitDamaged(params, "Ignored malformed context_snapshot event");
@@ -15312,7 +15705,7 @@ function emitDamaged(params, detail) {
 
 // src/storage/session-store/prune-helpers.ts
 import * as fsp13 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as path24 from "node:path";
 function isPrunableSessionJsonl(name) {
   return name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
 }
@@ -15320,7 +15713,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
   let deleted = 0;
   const pruneFile = async (dir, name, prefix) => {
-    const jsonlPath = path22.join(dir, name);
+    const jsonlPath = path24.join(dir, name);
     try {
       const stat10 = await fsp13.stat(jsonlPath);
       if (stat10.mtimeMs >= cutoff) return;
@@ -15339,7 +15732,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
       continue;
     }
     if (!entry.isDirectory()) continue;
-    const dateDir = path22.join(storeDir, entry.name);
+    const dateDir = path24.join(storeDir, entry.name);
     const files = await fsp13.readdir(dateDir, { withFileTypes: true }).catch(() => []);
     for (const file of files) {
       if (!file.isFile() || !isPrunableSessionJsonl(file.name)) continue;
@@ -15348,7 +15741,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dateDir = path22.join(storeDir, entry.name);
+    const dateDir = path24.join(storeDir, entry.name);
     try {
       const remaining = await fsp13.readdir(dateDir);
       if (remaining.length === 0) {
@@ -15681,6 +16074,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   logger;
   onAppend;
   onAppendBatch;
+  /** Present in built production output; source-only tests retain the local compatibility path. */
+  catalogClient;
+  maintenanceHolderId = randomUUID12();
   /**
    * In-memory cache for load() results, keyed by session ID. The cache is
    * invalidated when the file's mtimeMs or size changes (indicating the
@@ -15698,9 +16094,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
-    this.projectRoot = opts.projectRoot ? path23.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path25.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path23.join(this.dir, "_cas"),
+      rootDir: path25.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     this.events = opts.events;
@@ -15709,6 +16105,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.logger = opts.logger;
     this.onAppend = opts.onAppend;
     this.onAppendBatch = opts.onAppendBatch;
+    const builtRuntime = import.meta.url.includes("/dist/");
+    this.catalogClient = this.projectRoot && (builtRuntime || process.env["WRONGSTACK_SESSION_CATALOG_FORCE"] === "1") && resolveSessionCatalogProjectServerUrl() ? new SessionCatalogProjectClient({
+      projectDir: path25.dirname(this.dir),
+      projectRoot: this.projectRoot
+    }) : void 0;
   }
   /**
    * Emit a structured warning. Uses the configured Logger when available;
@@ -15731,10 +16132,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
   clearLoadCache(sessionId) {
     this.loadCache.clear(sessionId);
   }
+  async dispose() {
+    await this.catalogClient?.close();
+    this.clearLoadCache();
+  }
   // ── Storage event helpers ───────────────────────────────────────────────────
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path23.join(this.dir, "_index.jsonl");
+    return path25.join(this.dir, "_index.jsonl");
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
@@ -15792,8 +16197,23 @@ var DefaultSessionStore = class _DefaultSessionStore {
           if (!current) return null;
           return current.name === void 0 ? {} : { name: sessionContentText(this.secretScrubber.scrub(current.name)) };
         },
-        onClose: (s) => this.appendToIndex(s)
+        onClose: (s) => this.persistCatalogSummary(s)
       });
+      if (this.catalogClient) {
+        await this.catalogClient.call("upsert_summary", {
+          summary: {
+            id,
+            title: meta.title ?? "",
+            startedAt,
+            model: meta.model ?? "",
+            provider: meta.provider ?? "",
+            tokenTotal: 0,
+            lastActivityAt: startedAt
+          },
+          transcriptRelativePath: `${id}.jsonl`,
+          summaryRelativePath: `${id}.summary.json`
+        });
+      }
       emitSessionStoreWrite(this.events, id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
@@ -15823,6 +16243,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return materializeCheckpoint(this.checkpointCas, checkpoint, targetRoot);
   }
   async resolveId(query) {
+    if (this.catalogClient) {
+      return this.catalogClient.call("resolve_id", { query });
+    }
     const normalized = query.trim();
     if (!normalized) throw new Error("Session not found: (empty query)");
     if (normalized) {
@@ -15929,7 +16352,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
-          dir: path23.dirname(file),
+          dir: path25.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
           checkpointCas: this.checkpointCas,
@@ -15940,7 +16363,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             if (!current) return null;
             return current.name === void 0 ? {} : { name: sessionContentText(this.secretScrubber.scrub(current.name)) };
           },
-          onClose: (s) => this.appendToIndex(s)
+          onClose: (s) => this.persistCatalogSummary(s)
         }
       );
       emitSessionStoreWrite(this.events, canonicalId, file, "resume", "success", Date.now() - t0);
@@ -16053,6 +16476,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
   }
   async list(limit = 20) {
+    if (this.catalogClient) {
+      const records = await this.catalogClient.call("list_catalog", { limit });
+      return this.scrubSummaries(records);
+    }
     try {
       const indexed = await this.readIndex();
       if (indexed.length > 0) {
@@ -16075,6 +16502,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async listFiltered(criteria) {
     const limit = criteria.limit ?? 100;
+    if (this.catalogClient) {
+      const records = await this.catalogClient.call("list_catalog", {
+        limit: Math.min(1e3, Math.max(limit, 100)),
+        ...criteria.titleContains ? { search: criteria.titleContains } : {}
+      });
+      return this.scrubSummaries(records).filter((summary) => matchesSessionFilter(summary, criteria)).slice(0, limit);
+    }
     try {
       const indexed = await this.readIndex();
       if (indexed.length === 0) {
@@ -16124,6 +16558,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
     await this.appendToIndexStrict(summary).catch(() => {
     });
   }
+  /** Final summary boundary: daemon is authoritative when available. */
+  async persistCatalogSummary(summary) {
+    if (!this.catalogClient) {
+      await this.appendToIndex(summary);
+      return;
+    }
+    await this.catalogClient.call("upsert_summary", {
+      summary,
+      transcriptRelativePath: `${summary.id}.jsonl`,
+      summaryRelativePath: `${summary.id}.summary.json`
+    });
+  }
   /** Append a tombstone entry for a deleted session. */
   async writeTombstone(id) {
     try {
@@ -16233,6 +16679,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * fresh _index.jsonl. Useful after manual cleanup or index corruption.
    */
   async rebuildIndex() {
+    if (this.catalogClient) {
+      const result = await this.catalogClient.call("rebuild_catalog", {}, { timeoutMs: 12e4 });
+      return result.indexed;
+    }
     const ids = await this.collectSessionIds(this.dir);
     const summaries = await Promise.all(
       ids.map((id) => this.summaryFor(id).catch(() => null))
@@ -16302,7 +16752,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path23.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path25.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
     return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
@@ -16398,10 +16848,35 @@ var DefaultSessionStore = class _DefaultSessionStore {
     await this.writeTombstone(id);
   }
   async delete(id) {
+    if (this.catalogClient) {
+      const canonical = await this.resolveId(id);
+      const lease = await this.catalogClient.call("acquire_maintenance", {
+        sessionId: canonical,
+        operation: "delete",
+        holderId: this.maintenanceHolderId
+      });
+      try {
+        await this.catalogClient.call("delete", { sessionId: canonical, lease });
+      } catch (error) {
+        await this.catalogClient.call("release_maintenance", { lease }).catch(() => void 0);
+        throw error;
+      }
+      this.clearLoadCache(canonical);
+      return;
+    }
     await assertSessionCanBeDeleted(id, this.isSessionInUse);
     await this.deleteSession(id);
   }
   async rename(id, name) {
+    if (this.catalogClient) {
+      const canonical = await this.resolveId(id);
+      const summary = await this.catalogClient.call("rename", {
+        sessionId: canonical,
+        name: sessionContentText(this.secretScrubber.scrub(name))
+      });
+      this.clearLoadCache(canonical);
+      return summary;
+    }
     const trimmed = sessionContentText(this.secretScrubber.scrub(name));
     const manifest = this.sessionPath(id, ".summary.json");
     const jsonlPath = this.sessionPath(id, ".jsonl");
@@ -16453,6 +16928,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return updated;
   }
   async prune(maxAgeDays = 30) {
+    if (this.catalogClient) {
+      return this.catalogClient.call("prune", {
+        maxAgeDays,
+        holderId: this.maintenanceHolderId
+      });
+    }
     const deleted = await pruneSessionFiles(this.dir, maxAgeDays, (id) => this.deleteSession(id));
     if (deleted > 0) {
       await this.compactIndex().catch(() => void 0);
@@ -16460,20 +16941,81 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return deleted;
   }
   async clearHistory(id) {
-    await this.ensureShardDir(id);
-    const file = this.sessionPath(id, ".jsonl");
-    const meta = this.sessionPath(id, ".summary.json");
+    const canonical = this.catalogClient ? await this.resolveId(id) : id;
+    const maintenance = this.catalogClient ? await this.catalogClient.call("acquire_maintenance", {
+      sessionId: canonical,
+      operation: "clear",
+      holderId: this.maintenanceHolderId
+    }) : void 0;
+    await this.ensureShardDir(canonical);
+    const file = this.sessionPath(canonical, ".jsonl");
+    const meta = this.sessionPath(canonical, ".summary.json");
+    const backupSuffix = maintenance ? `.${maintenance.leaseId}.clear-backup` : void 0;
+    const fileBackup = backupSuffix ? `${file}${backupSuffix}` : void 0;
+    const metaBackup = backupSuffix ? `${meta}${backupSuffix}` : void 0;
+    let fileStaged = false;
+    let metaStaged = false;
     const record = `${JSON.stringify({
       type: "session_start",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
-      id,
+      id: canonical,
       model: "unknown",
       provider: "unknown"
     })}
 `;
-    await atomicWrite(file, record);
-    await fsp17.unlink(meta).catch(() => void 0);
-    this.clearLoadCache(id);
+    try {
+      if (fileBackup) {
+        try {
+          await fsp17.rename(file, fileBackup);
+          fileStaged = true;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+      }
+      if (metaBackup) {
+        try {
+          await fsp17.rename(meta, metaBackup);
+          metaStaged = true;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+      }
+      await atomicWrite(file, record);
+      if (!metaBackup) await fsp17.unlink(meta).catch(() => void 0);
+      if (this.catalogClient) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await this.catalogClient.call("upsert_summary", {
+          summary: {
+            id: canonical,
+            title: "",
+            startedAt: now,
+            model: "unknown",
+            provider: "unknown",
+            tokenTotal: 0,
+            lastActivityAt: now
+          },
+          transcriptRelativePath: `${canonical}.jsonl`,
+          summaryRelativePath: `${canonical}.summary.json`
+        });
+      }
+      if (fileStaged && fileBackup) await fsp17.unlink(fileBackup).catch(() => void 0);
+      if (metaStaged && metaBackup) await fsp17.unlink(metaBackup).catch(() => void 0);
+    } catch (error) {
+      if (fileStaged && fileBackup) {
+        await fsp17.unlink(file).catch(() => void 0);
+        await fsp17.rename(fileBackup, file).catch(() => void 0);
+      }
+      if (metaStaged && metaBackup) {
+        await fsp17.unlink(meta).catch(() => void 0);
+        await fsp17.rename(metaBackup, meta).catch(() => void 0);
+      }
+      throw error;
+    } finally {
+      if (maintenance && this.catalogClient) {
+        await this.catalogClient.call("release_maintenance", { lease: maintenance }).catch(() => void 0);
+      }
+    }
+    this.clearLoadCache(canonical);
   }
   async summarize(id, mtime) {
     return summarizeSessionFile({
@@ -16493,9 +17035,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path24.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path26.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path24.join(opts.sessionsRoot, runId);
+    dir = path26.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -16519,7 +17061,7 @@ function makeDirectorSessionFactory(opts) {
 }
 async function readDirectorSubagentSession(args) {
   if (!args.sessionsRoot) return null;
-  const filePath = path24.join(args.sessionsRoot, args.directorRunId, `${args.subagentId}.jsonl`);
+  const filePath = path26.join(args.sessionsRoot, args.directorRunId, `${args.subagentId}.jsonl`);
   let raw;
   try {
     raw = await fsp18.readFile(filePath, "utf8");
@@ -17663,7 +18205,7 @@ function formatRole(role) {
 }
 
 // src/coordination/fleet-spawn.ts
-async function spawn3(host, config, priceLookup) {
+async function spawn4(host, config, priceLookup) {
   if (host.workCompleteFlag) {
     throw new FleetSpawnBudgetError(
       "max_spawns",
@@ -17947,7 +18489,7 @@ function hashStr(s) {
 }
 
 // src/coordination/multi-agent-coordinator.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 import { EventEmitter as EventEmitter2 } from "node:events";
 
 // src/coordination/coordinator/error-classifier.ts
@@ -18086,12 +18628,12 @@ async function executeSubagentWithTimeout({
           }
           return new Promise((resolveDecision) => {
             let settled = false;
-            const resolve14 = (d) => {
+            const resolve16 = (d) => {
               if (settled) return;
               settled = true;
               resolveDecision(d);
             };
-            const fallback = setTimeout(() => resolve14("stop"), DECISION_TIMEOUT_MS);
+            const fallback = setTimeout(() => resolve16("stop"), DECISION_TIMEOUT_MS);
             const sessionId = currentSessionId();
             budget._events?.emit("budget.threshold_reached", {
               ...sessionId ? { sessionId } : {},
@@ -18101,11 +18643,11 @@ async function executeSubagentWithTimeout({
               timeoutMs: DECISION_TIMEOUT_MS,
               extend: (extra) => {
                 clearTimeout(fallback);
-                queueMicrotask(() => resolve14({ extend: extra }));
+                queueMicrotask(() => resolve16({ extend: extra }));
               },
               deny: () => {
                 clearTimeout(fallback);
-                resolve14("stop");
+                resolve16("stop");
               }
             });
           });
@@ -18243,7 +18785,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   pendingTasks = [];
   completedResults = [];
   /** Prevents completedResults from growing unbounded in long-running coordinators. */
-  static MAX_COMPLETED_RESULTS = 1e4;
+  static MAX_COMPLETED_RESULTS = 2e5;
   /** Caps each subagent's retained task history (see assign()); bounds RAM + the recordCompletion lookup. */
   static MAX_SUBAGENT_TASK_HISTORY = 64;
   totalIterations = 0;
@@ -18317,7 +18859,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     return { ...subagent, name: display };
   }
   async spawn(subagent) {
-    const id = subagent.id || randomUUID12();
+    const id = subagent.id || randomUUID13();
     const cfg = this.withNickname(subagent, id);
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -18492,7 +19034,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve14, reject) => {
+        return new Promise((resolve16, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -18501,7 +19043,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve14(result);
+              resolve16(result);
             }
           };
           this.on("task.completed", handler);
@@ -18526,13 +19068,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve16) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve14({
+        resolve16({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -18540,7 +19082,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve14({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve16({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -19202,7 +19744,7 @@ var Director = class _Director {
   sessionProvider;
   sessionModel;
   constructor(opts) {
-    this.id = opts.config.coordinatorId || randomUUID13();
+    this.id = opts.config.coordinatorId || randomUUID14();
     this.manifestPath = opts.manifestPath;
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -19464,7 +20006,7 @@ var Director = class _Director {
     }
     const config = { ...callerConfig };
     this.resolveSpawnModel(config);
-    const subagentId = await spawn3(this, config, priceLookup);
+    const subagentId = await spawn4(this, config, priceLookup);
     const perSubagentIdleMs = typeof config.idleTimeoutMs === "number" && Number.isFinite(config.idleTimeoutMs) && config.idleTimeoutMs >= 0 ? config.idleTimeoutMs : this.subagentIdleTimeoutMs;
     this.armSubagentIdleRetirement(subagentId, perSubagentIdleMs);
     return subagentId;
@@ -19485,7 +20027,7 @@ var Director = class _Director {
       );
     }
     const msg = {
-      id: randomUUID13(),
+      id: randomUUID14(),
       type: "task",
       from: this.id,
       to: subagentId,
@@ -19739,9 +20281,9 @@ var Director = class _Director {
 };
 
 // src/coordination/fleet-manager.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import * as fsp20 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as path27 from "node:path";
 var FleetManager = class {
   /** The fleet-wide event bus. */
   fleet;
@@ -19805,7 +20347,7 @@ var FleetManager = class {
   maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.directorRunId = opts.directorRunId ?? randomUUID14();
+    this.directorRunId = opts.directorRunId ?? randomUUID15();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = resolveMaxSpawnDepth(opts.maxSpawnDepth);
     this.spawnDepth = opts.spawnDepth ?? 0;
@@ -20074,7 +20616,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp20.mkdir(path25.dirname(this.manifestPath), { recursive: true });
+    await fsp20.mkdir(path27.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -20237,23 +20779,23 @@ var FleetManager = class {
 };
 
 // src/coordination/remote-mailbox.ts
-import * as path29 from "node:path";
+import * as path31 from "node:path";
 
 // src/coordination/mailbox-constants.ts
 var HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS = 1e4;
 var UNREAD_CHECK_MIN_INTERVAL_MS = 1e3;
 
 // src/coordination/mailbox-project-server-client.ts
-import { spawn as spawn4 } from "node:child_process";
-import * as fs3 from "node:fs";
-import * as net from "node:net";
-import * as path27 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { spawn as spawn5 } from "node:child_process";
+import * as fs4 from "node:fs";
+import * as net2 from "node:net";
+import * as path29 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/coordination/mailbox-project-server-endpoint.ts
-import { createHash as createHash5 } from "node:crypto";
-import * as os2 from "node:os";
-import * as path26 from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import * as os3 from "node:os";
+import * as path28 from "node:path";
 
 // src/coordination/mailbox-project-server-protocol.ts
 var MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION = 4;
@@ -20286,25 +20828,25 @@ function encodeMailboxProjectServerMessage(message) {
 // src/coordination/mailbox-project-server-endpoint.ts
 var MAILBOX_PROJECT_SERVER_METADATA_FILE = ".mailbox-server.json";
 function normalizeLocalPath(value) {
-  const resolved = path26.resolve(value);
+  const resolved = path28.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function mailboxProjectServerKey(projectDir) {
-  return createHash5("sha256").update(normalizeLocalPath(projectDir)).digest("hex").slice(0, 24);
+  return createHash6("sha256").update(normalizeLocalPath(projectDir)).digest("hex").slice(0, 24);
 }
 function mailboxProjectServerEndpoint(projectDir) {
   const key = mailboxProjectServerKey(projectDir);
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-mailbox-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path26.join(
-    os2.tmpdir(),
+  return path28.join(
+    os3.tmpdir(),
     `wsmb-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}`,
     `${key}.sock`
   );
 }
 function mailboxProjectServerMetadataPath(projectDir) {
-  return path26.join(path26.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
+  return path28.join(path28.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
 }
 
 // src/coordination/mailbox-project-server-client.ts
@@ -20315,7 +20857,7 @@ var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
 var AUTH_RETRY_DELAY_MS = 150;
 var AUTH_RETRY_MAX_ATTEMPTS = 13;
 function normalizePath(value) {
-  const resolved = path27.resolve(value);
+  const resolved = path29.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function resolveProjectServerUrl() {
@@ -20325,7 +20867,7 @@ function resolveProjectServerUrl() {
   ]) {
     try {
       const url = new URL(relative4, import.meta.url);
-      if (url.protocol === "file:" && fs3.existsSync(fileURLToPath3(url))) return url;
+      if (url.protocol === "file:" && fs4.existsSync(fileURLToPath4(url))) return url;
     } catch {
     }
   }
@@ -20334,8 +20876,8 @@ function resolveProjectServerUrl() {
 function isMailboxProjectServerAvailable() {
   return resolveProjectServerUrl() !== null;
 }
-function delay(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+function delay2(ms) {
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function isUnauthorizedMailboxError(error) {
   return error instanceof Error && error.name === "UnauthorizedMailboxRequest";
@@ -20343,7 +20885,7 @@ function isUnauthorizedMailboxError(error) {
 var MailboxProjectServerConnection = class {
   constructor(projectDir) {
     this.projectDir = projectDir;
-    this.projectDir = path27.resolve(projectDir);
+    this.projectDir = path29.resolve(projectDir);
     this.endpoint = mailboxProjectServerEndpoint(this.projectDir);
     this.state = {
       status: isMailboxProjectServerAvailable() ? "offline" : "unavailable",
@@ -20426,7 +20968,7 @@ var MailboxProjectServerConnection = class {
         lastError = error;
         const retriable = isUnauthorizedMailboxError(error) && attempt < AUTH_RETRY_MAX_ATTEMPTS;
         if (!retriable) throw error;
-        await delay(AUTH_RETRY_DELAY_MS);
+        await delay2(AUTH_RETRY_DELAY_MS);
       }
     }
     throw lastError;
@@ -20498,7 +21040,7 @@ var MailboxProjectServerConnection = class {
         this.spawnDetachedServer();
         spawned = true;
       }
-      await delay(75);
+      await delay2(75);
     }
     throw lastError;
   }
@@ -20508,8 +21050,8 @@ var MailboxProjectServerConnection = class {
     this.info = null;
     this.buffer = "";
     this.authToken = void 0;
-    return new Promise((resolve14, reject) => {
-      const socket = net.createConnection(this.endpoint);
+    return new Promise((resolve16, reject) => {
+      const socket = net2.createConnection(this.endpoint);
       this.socket = socket;
       socket.setEncoding("utf8");
       const timer = setTimeout(() => {
@@ -20523,7 +21065,7 @@ var MailboxProjectServerConnection = class {
         this.connectReject = null;
         this.startHeartbeat();
         this.transition("connected");
-        resolve14();
+        resolve16();
         void this.request({ type: "request", op: "ping", args: {} }, 3e3).catch(
           () => void 0
         );
@@ -20552,7 +21094,7 @@ var MailboxProjectServerConnection = class {
   currentAuthToken() {
     if (this.authToken === void 0) {
       try {
-        const raw = fs3.readFileSync(mailboxProjectServerMetadataPath(this.projectDir), "utf8");
+        const raw = fs4.readFileSync(mailboxProjectServerMetadataPath(this.projectDir), "utf8");
         const parsed = JSON.parse(raw);
         if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
           this.authToken = parsed.authToken;
@@ -20576,7 +21118,7 @@ var MailboxProjectServerConnection = class {
     if (encoded.length > MAILBOX_PROJECT_SERVER_MAX_FRAME_CHARS) {
       return Promise.reject(new Error("Mailbox project server request exceeded frame limit"));
     }
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve16, reject) => {
       const timer = setTimeout(() => {
         const pending = this.pending.get(id);
         if (!pending) return;
@@ -20584,7 +21126,7 @@ var MailboxProjectServerConnection = class {
         pending.reject(new Error(`Mailbox ${message.type} exceeded its ${timeoutMs}ms timeout`));
       }, timeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve14, reject, timer });
+      this.pending.set(id, { resolve: resolve16, reject, timer });
       socket.write(encoded);
     });
   }
@@ -20699,8 +21241,8 @@ var MailboxProjectServerConnection = class {
   spawnDetachedServer() {
     const url = resolveProjectServerUrl();
     if (!url) throw new Error("Mailbox project server entrypoint is unavailable");
-    fs3.mkdirSync(this.projectDir, { recursive: true });
-    const child = spawn4(process.execPath, [fileURLToPath3(url), "--project-dir", this.projectDir], {
+    fs4.mkdirSync(this.projectDir, { recursive: true });
+    const child = spawn5(process.execPath, [fileURLToPath4(url), "--project-dir", this.projectDir], {
       cwd: this.projectDir,
       detached: process.platform !== "win32",
       stdio: "ignore",
@@ -21021,9 +21563,9 @@ var CredentialVerifyThrottle = class {
 var credentialVerifyThrottle = new CredentialVerifyThrottle();
 
 // src/coordination/global-mailbox-paths.ts
-import * as path28 from "node:path";
+import * as path30 from "node:path";
 function resolveProjectDir(projectRoot, globalRoot) {
-  return path28.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path30.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 
 // src/coordination/sqlite-mailbox.ts
@@ -21073,8 +21615,8 @@ var RemoteMailbox = class {
       hqPublisher,
       eventEmitter
     } : optionsOrProjectDir;
-    this.projectDir = path29.resolve(options.projectDir);
-    this.messagePath = path29.join(this.projectDir, SQLITE_MAILBOX_FILE);
+    this.projectDir = path31.resolve(options.projectDir);
+    this.messagePath = path31.join(this.projectDir, SQLITE_MAILBOX_FILE);
     this.registryPath = this.messagePath;
     this.clientRegistryPath = this.messagePath;
     this.events = options.events;
@@ -21273,7 +21815,7 @@ var RemoteMailbox = class {
     this.hqSnapshotPendingMailboxId = mailboxId;
     if (this.hqSnapshotTimer !== void 0 || this.hqSnapshotInFlight !== void 0) return;
     const elapsed = Date.now() - this.hqSnapshotLastAt;
-    const delay2 = Math.max(0, HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS - elapsed);
+    const delay3 = Math.max(0, HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS - elapsed);
     this.hqSnapshotTimer = setTimeout(() => {
       this.hqSnapshotTimer = void 0;
       const pendingMailboxId = this.hqSnapshotPendingMailboxId;
@@ -21294,7 +21836,7 @@ var RemoteMailbox = class {
         }
       })();
       this.hqSnapshotInFlight = inFlight;
-    }, delay2);
+    }, delay3);
     this.hqSnapshotTimer.unref?.();
   }
   publishHqEvent(event) {
@@ -21320,7 +21862,7 @@ var RemoteMailbox = class {
       this.hqEventPending.clear();
       return;
     }
-    const mailboxId = `${path29.basename(this.projectDir)}:mailbox`;
+    const mailboxId = `${path31.basename(this.projectDir)}:mailbox`;
     const inFlight = this.query({ includeDeleted: true, limit: 100 }).then((messages) => {
       const message = messages.find((candidate) => candidate.id === event.messageId);
       const action = event.type === "message.sent" ? "message.sent" : "message.updated";
@@ -21343,7 +21885,7 @@ var RemoteMailbox = class {
     if (!publisher || !event.startsWith("mailbox.agent_") && !event.startsWith("mailbox.client_")) {
       return;
     }
-    const mailboxId = `${path29.basename(this.projectDir)}:mailbox`;
+    const mailboxId = `${path31.basename(this.projectDir)}:mailbox`;
     const record = typeof payload === "object" && payload !== null ? payload : {};
     const agentId = typeof record["agentId"] === "string" ? record["agentId"] : void 0;
     const action = event === "mailbox.agent_registered" ? "agent.registered" : event === "mailbox.agent_heartbeat" ? "agent.heartbeat" : event === "mailbox.agent_deregistered" ? "agent.deregistered" : void 0;
@@ -21366,7 +21908,7 @@ function createProjectMailbox(options) {
   return new RemoteMailbox(options);
 }
 function getSharedProjectMailbox(projectDir, events, hqPublisher) {
-  const key = path29.resolve(projectDir);
+  const key = path31.resolve(projectDir);
   let projectCache = sharedRemoteMailboxes.get(key);
   if (!projectCache) {
     projectCache = {
@@ -21406,12 +21948,12 @@ function getSharedProjectMailbox(projectDir, events, hqPublisher) {
 }
 
 // src/coordination/mailbox-tool.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function defaultResolveProjectDir(ctx) {
   return resolveProjectDir(ctx.projectRoot, wstackGlobalRoot());
 }
 function mailboxSessionTag(sessionId) {
-  return createHash6("sha256").update(sessionId).digest("hex").slice(0, 8);
+  return createHash7("sha256").update(sessionId).digest("hex").slice(0, 8);
 }
 function resolveMailboxIdentity(ctx, fallbackBase = "leader") {
   const fieldId = ctx.agentId && ctx.agentId !== "unknown" ? ctx.agentId : void 0;
@@ -21816,7 +22358,7 @@ function makeFleetStatusTool(opts = {}) {
 }
 
 // src/coordination/fleet-supervisor.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 var COLLAB_ID_PREFIXES2 = ["bug-hunter-", "refactor-planner-", "critic-"];
 var DEFAULTS = {
   intervalMs: 2e4,
@@ -22094,7 +22636,7 @@ var FleetSupervisor = class {
    */
   async decide(question, context, options, risk) {
     const request = {
-      id: `fleetsup-${randomUUID15()}`,
+      id: `fleetsup-${randomUUID16()}`,
       sessionId: this.opts.sessionId?.(),
       source: "system",
       question,
@@ -23734,16 +24276,16 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     throw validationError(`routePath must not start with '?' (got ${JSON.stringify(routePath)})`);
   }
   const queryIndex = url.indexOf("?");
-  const path34 = queryIndex === -1 ? url : url.slice(0, queryIndex);
+  const path36 = queryIndex === -1 ? url : url.slice(0, queryIndex);
   if (actor !== void 0) {
-    const requiredCapability = requiredCredentialCapability(method, path34);
+    const requiredCapability = requiredCredentialCapability(method, path36);
     if (requiredCapability === void 0) {
       writeJson(response, 403, {
-        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path34}` }
+        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path36}` }
       });
       return;
     }
-    if (path34 !== "/mailbox/send" && !hasMailboxCapability(actor, requiredCapability)) {
+    if (path36 !== "/mailbox/send" && !hasMailboxCapability(actor, requiredCapability)) {
       writeJson(response, 403, {
         error: {
           code: "FORBIDDEN",
@@ -23753,7 +24295,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
       return;
     }
   }
-  if (method === "POST" && path34 === "/mailbox/send") {
+  if (method === "POST" && path36 === "/mailbox/send") {
     const input = validateSend(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       const requiredCapability = requiredSendCapability(input.type);
@@ -23771,7 +24313,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 201, await mailbox.send(input));
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/query") {
+  if (method === "POST" && path36 === "/mailbox/query") {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -23791,7 +24333,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { data: projected, count: projected.length });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/check") {
+  if (method === "POST" && path36 === "/mailbox/check") {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -23825,7 +24367,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { data: projected, count: projected.length });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/ack") {
+  if (method === "POST" && path36 === "/mailbox/ack") {
     const input = validateAck(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       input.readerId = actor.actorId;
@@ -23839,7 +24381,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { updated: projectedAck });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/ack-many") {
+  if (method === "POST" && path36 === "/mailbox/ack-many") {
     const input = validateAckMany(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       const requestedIds = new Set(input.acks.map((ack) => ack.messageId));
@@ -23857,54 +24399,54 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { updated: projectedMany, count: projectedMany.length });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/unread-count") {
+  if (method === "POST" && path36 === "/mailbox/unread-count") {
     const body = await readJsonBody(request, maxBodyBytes);
     const count = actor === void 0 ? await mailbox.unreadCount(requireString2(body, "forAgentId")) : await unreadCountForActor(mailbox, actor);
     writeJson(response, 200, { count });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/agents/register") {
+  if (method === "POST" && path36 === "/mailbox/agents/register") {
     const input = validateAgentRegistration(await readJsonBody(request, maxBodyBytes), actor);
     await mailbox.registerAgent(input);
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path36 === "/mailbox/agents/heartbeat") {
     const input = validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) input.agentId = actor.actorId;
     await mailbox.heartbeat(input);
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/register-client") {
+  if (method === "POST" && path36 === "/mailbox/register-client") {
     await mailbox.registerClient(
       validateClientRegistration(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/heartbeat") {
+  if (method === "POST" && path36 === "/mailbox/heartbeat") {
     await mailbox.clientHeartbeat(
       validateClientHeartbeat(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path34 === "/mailbox/purge-clients") {
+  if (method === "POST" && path36 === "/mailbox/purge-clients") {
     writeJson(response, 200, { ok: true, purged: await mailbox.purgeClients() });
     return;
   }
-  if (method === "GET" && path34 === "/mailbox/agents") {
+  if (method === "GET" && path36 === "/mailbox/agents") {
     const agents = await mailbox.getAgentStatuses();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && path34 === "/mailbox/agents/online") {
+  if (method === "GET" && path36 === "/mailbox/agents/online") {
     const agents = await mailbox.getOnlineAgents();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && path34 === "/mailbox/events" && eventEmitter) {
+  if (method === "GET" && path36 === "/mailbox/events" && eventEmitter) {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -24013,25 +24555,25 @@ function requiredSendCapability(type) {
   }
   return "mail.send.informational";
 }
-function requiredCredentialCapability(method, path34) {
-  if (method === "POST" && path34 === "/mailbox/send") return "mail.send.informational";
-  if (method === "POST" && (path34 === "/mailbox/query" || path34 === "/mailbox/check")) {
+function requiredCredentialCapability(method, path36) {
+  if (method === "POST" && path36 === "/mailbox/send") return "mail.send.informational";
+  if (method === "POST" && (path36 === "/mailbox/query" || path36 === "/mailbox/check")) {
     return "mail.read.self";
   }
-  if (method === "POST" && (path34 === "/mailbox/ack" || path34 === "/mailbox/ack-many")) {
+  if (method === "POST" && (path36 === "/mailbox/ack" || path36 === "/mailbox/ack-many")) {
     return "mail.ack.self";
   }
-  if (method === "POST" && path34 === "/mailbox/unread-count") return "mail.read.self";
-  if (method === "POST" && path34 === "/mailbox/agents/register") {
+  if (method === "POST" && path36 === "/mailbox/unread-count") return "mail.read.self";
+  if (method === "POST" && path36 === "/mailbox/agents/register") {
     return "mail.presence.register.self";
   }
-  if (method === "POST" && path34 === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path36 === "/mailbox/agents/heartbeat") {
     return "mail.presence.heartbeat.self";
   }
-  if (method === "GET" && (path34 === "/mailbox/agents" || path34 === "/mailbox/agents/online")) {
+  if (method === "GET" && (path36 === "/mailbox/agents" || path36 === "/mailbox/agents/online")) {
     return "mail.presence.read";
   }
-  if (method === "GET" && path34 === "/mailbox/events") return "mail.events.self";
+  if (method === "GET" && path36 === "/mailbox/events") return "mail.events.self";
   return void 0;
 }
 function extractEventTimestamp(event) {
@@ -24233,16 +24775,16 @@ async function checkMailbox(mailbox, input, minTimestampIso, includeReceiptState
 var NULL_FLEET_BUS = new FleetBus();
 
 // src/coordination/package-author-tracker.ts
-import * as fs4 from "node:fs/promises";
-import * as path30 from "node:path";
+import * as fs5 from "node:fs/promises";
+import * as path32 from "node:path";
 var DEFAULT_MAX_ENTRIES2 = 1e4;
 var LOG_FILENAME2 = "package-authors.json";
 function logPath2(storageDir) {
-  return path30.join(storageDir, LOG_FILENAME2);
+  return path32.join(storageDir, LOG_FILENAME2);
 }
 async function loadLog2(storageDir, projectRoot) {
   try {
-    const raw = await fs4.readFile(logPath2(storageDir), "utf-8");
+    const raw = await fs5.readFile(logPath2(storageDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.entries || !Array.isArray(parsed.entries)) {
       return { projectRoot, entries: [] };
@@ -24260,7 +24802,7 @@ async function saveLog2(storageDir, log) {
 `);
 }
 function detectEcosystem(manifestPath) {
-  const name = path30.win32.basename(manifestPath).toLowerCase();
+  const name = path32.win32.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -25142,13 +25684,13 @@ var RemoteMailboxCredentialStore = class {
 import { randomBytes as randomBytes2 } from "node:crypto";
 import * as fsp21 from "node:fs/promises";
 import { execFile } from "node:child_process";
-import * as os3 from "node:os";
-import * as path31 from "node:path";
+import * as os4 from "node:os";
+import * as path33 from "node:path";
 var MAILBOX_BRIDGE_LOCK_FILENAME = ".mailbox-bridge.lock";
 var MAILBOX_BRIDGE_TOKEN_FILENAME = ".mailbox.token";
 async function acquireOrJoin(opts) {
-  const lockPath = path31.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path31.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path33.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path33.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const inspected = await readLockForInspection(lockPath);
   if (inspected.kind === "live") {
     const existing = inspected.lock;
@@ -25176,8 +25718,8 @@ async function acquireOrJoin(opts) {
   return { kind: "acquired", lock: tentative, tokenPath };
 }
 async function finalize(projectDir, tentative, boundPort) {
-  const lockPath = path31.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path31.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path33.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path33.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const finalized = {
     ...tentative,
     port: boundPort,
@@ -25188,8 +25730,8 @@ async function finalize(projectDir, tentative, boundPort) {
   return finalized;
 }
 async function release(projectDir, generation) {
-  const lockPath = path31.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path31.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path33.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path33.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   try {
     const raw = await fsp21.readFile(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -25223,7 +25765,7 @@ async function readLockForInspection(lockPath) {
   return { kind: "live", lock: parsed };
 }
 async function readLiveLock(projectDir) {
-  const lockPath = path31.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const lockPath = path33.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
   const result = await readLockForInspection(lockPath);
   if (result.kind === "live") {
     return { kind: "live", lock: result.lock };
@@ -25234,7 +25776,7 @@ async function readLiveLock(projectDir) {
   return { kind: "absent" };
 }
 async function atomicWriteJson(targetPath, value) {
-  const dir = path31.dirname(targetPath);
+  const dir = path33.dirname(targetPath);
   await fsp21.mkdir(dir, { recursive: true });
   const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes2(4).toString("hex")}`;
   const body = JSON.stringify(value, null, 2) + "\n";
@@ -25249,8 +25791,8 @@ async function atomicWriteJson(targetPath, value) {
 async function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   if (pid === process.pid) return true;
-  if (os3.platform() === "win32") {
-    return new Promise((resolve14) => {
+  if (os4.platform() === "win32") {
+    return new Promise((resolve16) => {
       execFile(
         "tasklist",
         ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"],
@@ -25262,11 +25804,11 @@ async function isProcessAlive(pid) {
         },
         (error, out) => {
           if (error) {
-            resolve14(false);
+            resolve16(false);
             return;
           }
           const match = /(?:^|\n)"[^"]*","(\d+)"/.exec(out);
-          resolve14(match !== null && match[1] === String(pid));
+          resolve16(match !== null && match[1] === String(pid));
         }
       );
     });
@@ -25397,8 +25939,8 @@ function extractManifestPath(msg) {
   }
   return void 0;
 }
-function isManifestFile(path34) {
-  const name = pathBasename(path34).toLowerCase();
+function isManifestFile(path36) {
+  const name = pathBasename(path36).toLowerCase();
   const manifests = [
     "package.json",
     "package-lock.json",
@@ -25691,8 +26233,8 @@ var AdaptiveConcurrencyController = class {
 
 // src/coordination/agent-monitor.ts
 import { createReadStream as createReadStream5 } from "node:fs";
-import * as fs5 from "node:fs/promises";
-import * as path32 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path34 from "node:path";
 import { createInterface as createInterface5 } from "node:readline";
 var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
@@ -25772,7 +26314,7 @@ var AgentMonitorService = class _AgentMonitorService {
   async loadSessionsFromDisk() {
     let subagentIds;
     try {
-      const dirents = await fs5.readdir(this._transcriptsDir, { withFileTypes: true });
+      const dirents = await fs6.readdir(this._transcriptsDir, { withFileTypes: true });
       subagentIds = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
       return this.getAllSessions();
@@ -25796,8 +26338,8 @@ var AgentMonitorService = class _AgentMonitorService {
     return this.getAllSessions();
   }
   async _readTranscriptFile(subagentId) {
-    const file = path32.join(this._transcriptsDir, subagentId, "transcript.jsonl");
-    const accessible = await fs5.access(file).then(() => true).catch(() => false);
+    const file = path34.join(this._transcriptsDir, subagentId, "transcript.jsonl");
+    const accessible = await fs6.access(file).then(() => true).catch(() => false);
     if (!accessible) return [];
     const out = [];
     const input = createReadStream5(file, { encoding: "utf8" });
@@ -26137,14 +26679,14 @@ var AgentMonitorService = class _AgentMonitorService {
     this._writeDrain = drain;
   }
   async _appendToFile(subagentId, line) {
-    const dir = path32.join(this._transcriptsDir, subagentId);
+    const dir = path34.join(this._transcriptsDir, subagentId);
     if (!this._ensuredDirs.has(dir)) {
-      await fs5.mkdir(dir, { recursive: true });
+      await fs6.mkdir(dir, { recursive: true });
       this._ensuredDirs.add(dir);
     }
-    const filePath = path32.join(dir, "transcript.jsonl");
+    const filePath = path34.join(dir, "transcript.jsonl");
     try {
-      await fs5.appendFile(filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      await fs6.appendFile(filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
     } catch (error) {
       this._ensuredDirs.delete(dir);
       throw error;
@@ -26188,7 +26730,7 @@ function createAgentMonitorService(opts) {
 }
 
 // src/coordination/autonomous-brain.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 var AutonomousBrain = class {
   graph;
   // Fleet bus for emitting decisions — null-safe, no-op if not provided
@@ -26294,7 +26836,7 @@ var AutonomousBrain = class {
       consequence: i === 0 ? `Spawn the most appropriate agent for: ${taskDescription.slice(0, 80)}` : `Spawn an alternative agent for the same task`
     }));
     return this.decideAuto({
-      id: randomUUID16(),
+      id: randomUUID17(),
       source,
       decisionType: "spawn",
       question: `Should we spawn a subagent for this task?`,
@@ -26337,7 +26879,7 @@ var AutonomousBrain = class {
       }
     ];
     return this.decideAuto({
-      id: randomUUID16(),
+      id: randomUUID17(),
       source,
       decisionType: "approve_change",
       question: `Should we approve the change "${change.title}"?`,
@@ -26396,7 +26938,7 @@ var AutonomousBrain = class {
       consequence: "Break the task into smaller sub-tasks"
     });
     return this.decideAuto({
-      id: randomUUID16(),
+      id: randomUUID17(),
       source,
       decisionType: "escalate_task",
       question: `Task failed: ${error.slice(0, 100)}. How should we proceed?`,
@@ -26530,12 +27072,12 @@ ${ctx.error}`);
 };
 
 // src/coordination/autonomous-coordinator.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 
 // src/coordination/knowledge-graph.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import * as fsp22 from "node:fs/promises";
-import * as path33 from "node:path";
+import * as path35 from "node:path";
 var DEFAULT_MAX_NODES = 2e3;
 var MAX_SUBSCRIPTIONS = 1e3;
 var MAX_PENDING_DELIVERIES_PER_SUBSCRIPTION = 1e3;
@@ -26570,8 +27112,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     return this.index;
   }
   constructor(sessionDir, maxNodes = DEFAULT_MAX_NODES, compactEveryWrites = Math.max(1e3, maxNodes * 4)) {
-    this.filePath = path33.join(sessionDir, "_knowledge_graph");
-    this.graphFilePath = path33.join(this.filePath, "graph.jsonl");
+    this.filePath = path35.join(sessionDir, "_knowledge_graph");
+    this.graphFilePath = path35.join(this.filePath, "graph.jsonl");
     this.maxNodes = maxNodes;
     this.compactEveryWrites = Math.max(1, Math.floor(compactEveryWrites));
   }
@@ -26581,7 +27123,7 @@ var KnowledgeGraph = class _KnowledgeGraph {
    * Returns the node with its assigned id.
    */
   async add(node) {
-    const full = { id: randomUUID17(), ...node };
+    const full = { id: randomUUID18(), ...node };
     this.nodes.set(full.id, full);
     this._trackSeq(full.id);
     this._addToIndex(full, this._indexKeys(full));
@@ -26710,8 +27252,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     if (this.subs.size >= MAX_SUBSCRIPTIONS) {
       throw new Error(`Knowledge graph subscription limit reached (${MAX_SUBSCRIPTIONS})`);
     }
-    const channel = randomUUID17();
-    const sub = { id: randomUUID17(), agentId, filter, channel };
+    const channel = randomUUID18();
+    const sub = { id: randomUUID18(), agentId, filter, channel };
     this.subs.set(channel, sub);
     this.pendingDeliveries.set(channel, []);
     return channel;
@@ -27192,7 +27734,7 @@ var TaskDAG = class {
 };
 
 // src/coordination/task-auctioneer.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function isTerminalGoalStatus(status) {
   return status === "done" || status === "failed";
 }
@@ -27315,7 +27857,7 @@ var TaskAuctioneer = class {
     const score = dispatchResult.confidence * (dispatchResult.role === agent.agentRole ? 1.2 : 1);
     if (score < this.minConfidence) return false;
     const bid = {
-      id: randomUUID18(),
+      id: randomUUID19(),
       taskId,
       agentId: agent.agentId,
       agentName: agent.agentName,
@@ -28252,7 +28794,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
           break;
         }
         const decision = await this.brain.decideAuto({
-          id: randomUUID19(),
+          id: randomUUID20(),
           source: "system",
           decisionType: "prioritize_goals",
           question: `What should we work on next? Open goals: ${dispatchable.map((g) => g.title).join(", ")}`,
@@ -28483,17 +29025,17 @@ ${input.detail}`
   _waitForDagProgress(timeoutMs) {
     const before = this._dagProgressKey();
     if (this.dag.isDone()) return Promise.resolve();
-    return new Promise((resolve14) => {
+    return new Promise((resolve16) => {
       let off;
       const timer = setTimeout(() => {
         off?.();
-        resolve14();
+        resolve16();
       }, timeoutMs);
       off = this.dag.onEvent(() => {
         if (this._dagProgressKey() === before) return;
         clearTimeout(timer);
         off?.();
-        resolve14();
+        resolve16();
       });
     });
   }
@@ -28801,8 +29343,8 @@ var CollaborationBus = class _CollaborationBus {
     if (this.isPaused()) return false;
     this.pausedAtMs = Date.now();
     this.pausedBy = byParticipant;
-    this.pausePromise = new Promise((resolve14) => {
-      this.pauseResolve = resolve14;
+    this.pausePromise = new Promise((resolve16) => {
+      this.pauseResolve = resolve16;
     });
     return true;
   }
@@ -28838,8 +29380,8 @@ var CollaborationBus = class _CollaborationBus {
       return true;
     }
     let timer;
-    const timeoutPromise = new Promise((resolve14) => {
-      timer = setTimeout(() => resolve14("timeout"), timeoutMs);
+    const timeoutPromise = new Promise((resolve16) => {
+      timer = setTimeout(() => resolve16("timeout"), timeoutMs);
     });
     const resumedPromise = this.pausePromise.then(() => "resumed").catch(() => "resumed");
     const winner = await Promise.race([resumedPromise, timeoutPromise]);