@agenticmail/claudecode 0.2.2 → 0.2.4

package/dist/{chunk-T3J2WZMM.js → chunk-V5R2D3QD.js}

@@ -12191,7 +12191,7 @@ function rememberBounded(set, item) {
     for (const x of drop) set.delete(x);
   }
 }
-var DEFAULT_MAX_CONCURRENT = 10;
+var DEFAULT_MAX_CONCURRENT = 50;
 var DEFAULT_SYNC_INTERVAL_MS = 3e4;
 var DEFAULT_RECONNECT_BASE_MS = 2e3;
 var DEFAULT_RECONNECT_MAX_MS = 6e4;
@@ -13184,6 +13184,7 @@ var Dispatcher = class {
   }
   /** Acquire a concurrency slot, run a worker, release the slot. */
   async spawnWorker(account, prompt, ctx) {
+    const releaseAgentLock = await this.acquireAgentSerial(account.id);
     await this.acquireSlot();
     const workerId = `${account.id}:${ctx.kind}:${ctx.uid ?? ctx.taskId ?? ""}:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     let workerResult = null;
@@ -13221,12 +13222,18 @@ var Dispatcher = class {
     let turnCount = 0;
     let lastTool = "";
     let lastUsage;
+    const digestedUids = /* @__PURE__ */ new Set();
     const observer = {
       onMessage: (tag, summary) => {
         writeLog(`${tag} ${summary}`);
         if (tag === "tool_use") {
           lastTool = summary.split(" ")[0];
           turnCount++;
+          const m = /read_email\b[^}]*"uid"\s*:\s*(\d+)/.exec(summary);
+          if (m) {
+            const uid = parseInt(m[1], 10);
+            if (Number.isFinite(uid) && uid > 0) digestedUids.add(uid);
+          }
         }
         if (tag === "usage") lastUsage = summary;
       }
@@ -13266,6 +13273,30 @@ var Dispatcher = class {
     } finally {
       clearInterval(heartbeatHandle);
       this.releaseSlot();
+      if (digestedUids.size > 0) {
+        const prefix = `${account.id}::`;
+        for (const [key, entry] of this.wakeCoalesce.entries()) {
+          if (!key.startsWith(prefix)) continue;
+          const before = entry.events.length;
+          entry.events = entry.events.filter((e) => !(typeof e.uid === "number" && digestedUids.has(e.uid)));
+          if (entry.events.length < before) {
+            this.log("info", `[dispatcher] dropped ${before - entry.events.length} queued wake(s) for "${account.name}" \u2014 UIDs already digested this turn`);
+          }
+          if (entry.events.length === 0) {
+            try {
+              clearTimeout(entry.timer);
+            } catch {
+            }
+            this.wakeCoalesce.delete(key);
+          }
+        }
+        const ch = this.channels.get(account.id);
+        if (ch) for (const uid of digestedUids) rememberBounded(ch.seenUids, uid);
+      }
+      try {
+        releaseAgentLock();
+      } catch {
+      }
       const ok = workerResult?.ok === true;
       const preview = workerResult?.ok ? workerResult.text : workerResult ? workerResult.error : "worker did not start";
       writeLog(`worker_finished ok=${ok} chars=${preview.length}`);
@@ -13371,6 +13402,41 @@ var Dispatcher = class {
     const next = this.waiters.shift();
     if (next) next();
   }
+  /**
+   * Per-agent serialization. At most ONE worker runs for any
+   * given agent at a time. When a new wake fires for an agent
+   * whose worker is still running, the new wake's spawnWorker
+   * waits on the prior worker's tail before proceeding.
+   *
+   * This is the fix for the "dispatcher crashed when sender
+   * broadcast to a 5-CC thread" failure mode: under the old
+   * design, 5 emails landing for vesper-on-3-different-threads
+   * in the same second spawned 5 simultaneous vesper workers,
+   * each opening its own IMAP connection, each calling the
+   * SDK, racing on the same inbox cache. With this gate they
+   * queue tail-to-head and run sequentially.
+   *
+   * `nextRun` is a chained promise: each new spawn calls
+   * `then()` on the previous tail so the order is preserved.
+   * When the chain resolves to a no-op (empty queue), the
+   * entry is garbage-collected from the map so memory stays
+   * bounded at #active-agents.
+   */
+  agentSerial = /* @__PURE__ */ new Map();
+  async acquireAgentSerial(agentId) {
+    const prev = this.agentSerial.get(agentId);
+    let release;
+    const next = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.agentSerial.set(agentId, prev ? prev.then(() => next).catch(() => next) : next);
+    if (prev) await prev.catch(() => {
+    });
+    return () => {
+      release();
+      if (this.agentSerial.get(agentId) === next) this.agentSerial.delete(agentId);
+    };
+  }
 };
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/dispatcher-bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   Dispatcher
-} from "./chunk-T3J2WZMM.js";
+} from "./chunk-V5R2D3QD.js";
 import "./chunk-DDJNA5HP.js";
 import "./chunk-B276KPVO.js";
 import "./chunk-RB5MGRT3.js";
@@ -31,7 +31,10 @@ async function main() {
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);
   process.on("unhandledRejection", (reason) => {
-    console.error("[dispatcher-bin] unhandledRejection:", reason);
+    console.error("[dispatcher-bin] unhandledRejection (continuing):", reason);
+  });
+  process.on("uncaughtException", (err) => {
+    console.error("[dispatcher-bin] uncaughtException (continuing):", err);
   });
   await dispatcher.start();
 }

package/dist/dispatcher.d.ts

@@ -348,6 +348,28 @@ declare class Dispatcher {
     private buildMcpEnv;
     private acquireSlot;
     private releaseSlot;
+    /**
+     * Per-agent serialization. At most ONE worker runs for any
+     * given agent at a time. When a new wake fires for an agent
+     * whose worker is still running, the new wake's spawnWorker
+     * waits on the prior worker's tail before proceeding.
+     *
+     * This is the fix for the "dispatcher crashed when sender
+     * broadcast to a 5-CC thread" failure mode: under the old
+     * design, 5 emails landing for vesper-on-3-different-threads
+     * in the same second spawned 5 simultaneous vesper workers,
+     * each opening its own IMAP connection, each calling the
+     * SDK, racing on the same inbox cache. With this gate they
+     * queue tail-to-head and run sequentially.
+     *
+     * `nextRun` is a chained promise: each new spawn calls
+     * `then()` on the previous tail so the order is preserved.
+     * When the chain resolves to a no-op (empty queue), the
+     * entry is garbage-collected from the map so memory stays
+     * bounded at #active-agents.
+     */
+    private agentSerial;
+    private acquireAgentSerial;
 }
 
 export { Dispatcher, type DispatcherOptions, type QueryFn, type WorkerObserver };

package/dist/dispatcher.js

@@ -1,6 +1,6 @@
 import {
   Dispatcher
-} from "./chunk-T3J2WZMM.js";
+} from "./chunk-V5R2D3QD.js";
 import "./chunk-DDJNA5HP.js";
 import "./chunk-B276KPVO.js";
 import "./chunk-RB5MGRT3.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   Dispatcher,
   loadPersonaForAgent
-} from "./chunk-T3J2WZMM.js";
+} from "./chunk-V5R2D3QD.js";
 import "./chunk-DDJNA5HP.js";
 import "./chunk-B276KPVO.js";
 import "./chunk-RB5MGRT3.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/claudecode",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Claude Code integration for AgenticMail — surfaces every AgenticMail agent as a native Claude Code subagent so any Claude Code session can delegate to them with the Agent tool",
   "type": "module",
   "main": "dist/index.js",