@agenticmail/claudecode 0.1.16 → 0.2.0

package/dist/chunk-RNKJRBEF.js

@@ -1,916 +0,0 @@
-import {
-  listAccounts,
-  renderPersonaBody,
-  resolveConfig
-} from "./chunk-SBP7MJP2.js";
-
-// src/persona-loader.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-function sanitizeSubagentName(name) {
-  return name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function stripFrontmatter(raw) {
-  const text = raw.replace(/\r\n/g, "\n");
-  if (!text.startsWith("---\n")) return text;
-  const close = text.indexOf("\n---", 4);
-  if (close < 0) return text;
-  let cursor = close + 4;
-  while (cursor < text.length && (text[cursor] === "\n" || text[cursor] === "\r")) cursor++;
-  return text.slice(cursor);
-}
-function loadPersonaForAgent(opts) {
-  const { agent, agentsDir, subagentPrefix, mcpServerName } = opts;
-  const basename = sanitizeSubagentName(`${subagentPrefix}${agent.name}`);
-  const filePath = join(agentsDir, `${basename}.md`);
-  if (existsSync(filePath)) {
-    try {
-      const raw = readFileSync(filePath, "utf-8");
-      const body2 = stripFrontmatter(raw).trim();
-      if (body2) return { body: body2, source: "file", filePath };
-    } catch {
-    }
-  }
-  const body = renderPersonaBody({ name: basename, agent, mcpServerName });
-  return { body, source: "generated" };
-}
-
-// src/dispatcher.ts
-import { mkdirSync, createWriteStream, rmSync } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
-function extractSubject(event) {
-  if (typeof event.subject === "string") return event.subject;
-  if (event.message && typeof event.message.subject === "string") return event.message.subject;
-  return void 0;
-}
-function extractFrom(event) {
-  if (typeof event.from === "string") return event.from;
-  if (event.message && Array.isArray(event.message.from)) {
-    const first = event.message.from[0];
-    if (first?.address) return first.address;
-    if (first?.name) return first.name;
-  }
-  return void 0;
-}
-function extractWakeAllowlist(event) {
-  const raw = event.wakeAllowlist;
-  if (raw === void 0) return void 0;
-  if (!Array.isArray(raw)) return void 0;
-  return raw.map((x) => String(x).trim().toLowerCase()).filter(Boolean);
-}
-function isAgentOnWakeAllowlist(accountName, list) {
-  if (list === void 0) return true;
-  if (list.length === 0) return false;
-  return list.includes(accountName.trim().toLowerCase());
-}
-var SEEN_CAP = 1024;
-function rememberBounded(set, item) {
-  set.add(item);
-  if (set.size > SEEN_CAP) {
-    const drop = Array.from(set).slice(0, Math.floor(SEEN_CAP / 2));
-    for (const x of drop) set.delete(x);
-  }
-}
-var DEFAULT_MAX_CONCURRENT = 10;
-var DEFAULT_SYNC_INTERVAL_MS = 3e4;
-var DEFAULT_RECONNECT_BASE_MS = 2e3;
-var DEFAULT_RECONNECT_MAX_MS = 6e4;
-var TASK_MAIL_SUPPRESS_WINDOW_MS = 3e4;
-var TASK_NOTIFICATION_SUBJECT_PREFIXES = ["[RPC]", "[Task]", "[Async-RPC]"];
-function isTaskNotificationSubject(subject) {
-  if (!subject) return false;
-  const head = subject.trimStart();
-  for (const prefix of TASK_NOTIFICATION_SUBJECT_PREFIXES) {
-    if (head.toLowerCase().startsWith(prefix.toLowerCase())) return true;
-  }
-  return false;
-}
-var THREAD_CLOSED_MARKERS = ["[FINAL]", "[DONE]", "[CLOSED]", "[WRAP]"];
-function isThreadClosedSubject(subject) {
-  if (!subject) return false;
-  const s = subject.toLowerCase();
-  return THREAD_CLOSED_MARKERS.some((m) => s.includes(m.toLowerCase()));
-}
-function threadIdFromSubject(subject) {
-  if (!subject) return "";
-  let s = subject.trim();
-  while (true) {
-    const next = s.replace(/^(re|fwd?|fw)(\[\d+\])?:\s*/i, "");
-    if (next === s) break;
-    s = next;
-  }
-  return s.toLowerCase().trim();
-}
-var DEFAULT_MAX_WAKES_PER_THREAD = 10;
-var DEFAULT_WAKE_WINDOW_MS = 24 * 60 * 60 * 1e3;
-async function runWorker(query, persona, userPrompt, agent, mcpServerName, mcpCommand, mcpArgs, mcpEnv, log, abortSignal, observer, cwd) {
-  const opts = {
-    systemPrompt: persona,
-    mcpServers: {
-      [mcpServerName]: {
-        command: mcpCommand,
-        args: mcpArgs,
-        env: mcpEnv
-      }
-    },
-    // No `allowedTools` restriction.
-    //
-    // Earlier versions of the dispatcher locked workers to MCP-only tools
-    // ("you operate an email account, not a developer environment"). That
-    // was the wrong design: AgenticMail agents are real Claude Code
-    // subagents running under the host's OAuth, and the work humans
-    // delegate to them (write code, run tests, do research, edit files)
-    // demands the full native toolset (Read, Write, Edit, Bash, Glob,
-    // Grep, WebFetch, WebSearch, NotebookEdit, …). Restricting them
-    // turned "Zephyr implements the game" into "Zephyr emails source
-    // code as plaintext and the human has to copy-paste it" — which
-    // defeats the point of having agents in the first place.
-    //
-    // Omitting allowedTools lets the SDK fall through to its defaults
-    // (all built-in tools + every tool exposed by the MCP servers we
-    // declare above). Outbound mail is still guarded by AgenticMail's
-    // own outbound guard (HIGH-severity sends held for owner approval)
-    // and the worker is sandboxed by Claude Code's permission system
-    // just like any other subagent.
-    permissionMode: "bypassPermissions",
-    abortController: abortSignal ? wrapSignal(abortSignal) : void 0
-  };
-  if (cwd) opts.cwd = cwd;
-  const collectedText = [];
-  try {
-    for await (const msg of query({ prompt: userPrompt, options: opts })) {
-      const m = msg;
-      if (m.type === "assistant" && Array.isArray(m.message && m.message.content)) {
-        for (const block of m.message.content) {
-          const b = block;
-          if (b.type === "text" && typeof b.text === "string") {
-            collectedText.push(b.text);
-            if (observer) observer.onMessage("assistant", b.text.slice(0, 240).replace(/\s+/g, " ").trim());
-          } else if (b.type === "tool_use" && typeof b.name === "string") {
-            const inputSummary = (() => {
-              try {
-                return JSON.stringify(b.input).slice(0, 200);
-              } catch {
-                return "(uninspectable input)";
-              }
-            })();
-            if (observer) observer.onMessage("tool_use", `${b.name} ${inputSummary}`);
-          }
-        }
-      } else if (m.type === "user" && Array.isArray(m.message && m.message.content)) {
-        for (const block of m.message.content) {
-          const b = block;
-          if (b.type === "tool_result") {
-            const bodyStr = typeof b.content === "string" ? b.content : Array.isArray(b.content) ? b.content.map((c) => c.text ?? "").join(" ") : "";
-            if (observer) observer.onMessage("tool_result", bodyStr.slice(0, 240).replace(/\s+/g, " ").trim());
-          }
-        }
-      }
-      if (m.type === "result" && typeof m.result === "string") {
-        collectedText.push(m.result);
-        if (observer) observer.onMessage("result", m.result.slice(0, 240).replace(/\s+/g, " ").trim());
-      }
-    }
-    const text = collectedText.join("\n").trim();
-    log("info", `[dispatcher] worker for "${agent.name}" finished (${text.length} chars output)`);
-    return { ok: true, text };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    log("error", `[dispatcher] worker for "${agent.name}" failed: ${msg}`);
-    if (observer) observer.onMessage("error", msg);
-    return { ok: false, error: msg };
-  }
-}
-function wrapSignal(signal) {
-  const c = new AbortController();
-  if (signal.aborted) c.abort();
-  else signal.addEventListener("abort", () => c.abort(), { once: true });
-  return c;
-}
-function newMailPrompt(agent, event) {
-  const from = extractFrom(event) ?? "unknown sender";
-  const subject = extractSubject(event) ?? "(no subject)";
-  const uid = event.uid;
-  return [
-    `You have new mail.`,
-    ``,
-    `- From: ${from}`,
-    `- Subject: ${subject}`,
-    uid ? `- UID: ${uid}` : "",
-    ``,
-    `## Thread-aware coordination protocol`,
-    ``,
-    `You are ${agent.name}. Multiple agents may be CC'd on the same thread \u2014`,
-    `that is intentional: a thread is the shared workspace, and turn-taking is`,
-    `implicit from context (who was addressed last, whose stage of the workflow`,
-    `is next, who was @mentioned). Follow these steps in order:`,
-    ``,
-    `1. **Read this message.** read_email({ uid: ${uid ?? "<uid>"}, _account: "${agent.name}" }).`,
-    ``,
-    `2. **If this is a reply (Subject starts with "Re:" or an In-Reply-To header is present), load the rest of the thread.**`,
-    `   Use search_emails({ subject: "<core subject without Re:>", _account: "${agent.name}" })`,
-    `   to surface earlier messages in the thread, then read_email each prior UID.`,
-    `   You MUST read the full thread before deciding what to do.`,
-    ``,
-    `3. **CHECK YOUR PRIOR CONTRIBUTIONS to this thread.** When you searched`,
-    `   in step 2, look at how many of the messages were sent BY YOU`,
-    `   (from: ${agent.email}). If you have already contributed your work`,
-    `   to this thread, **do NOT redo it on a new wake**. Redelivering`,
-    `   identical content when a teammate posts an update is the most`,
-    `   common multi-agent failure mode \u2014 it triples noise and wastes`,
-    `   tokens. Only re-contribute if EITHER:`,
-    `     (a) the latest reply contains a NEW specific ask addressed to`,
-    `         you by name and you have not yet answered THAT ask, OR`,
-    `     (b) a teammate's reply genuinely changes the picture and your`,
-    `         prior work needs an explicit revision (not a re-post).`,
-    `   Otherwise stay silent.`,
-    ``,
-    `4. **Identify the participants.** Look at To + CC across the thread. Those`,
-    `   are your collaborators. Their names map to AgenticMail agents at`,
-    `   <name>@localhost. They will each be woken on every reply-all the same way you were.`,
-    ``,
-    `5. **Decide: is it MY turn?** Yes if any of:`,
-    `     - The latest message addresses you by name ("Vesper, please \u2026", "@${agent.name} \u2026").`,
-    `     - The previous-stage handoff is to your role (e.g. designer \u2192 developer, and you are the developer).`,
-    `     - You were directly asked a question and nobody has answered yet.`,
-    `   No if:`,
-    `     - The current ask is targeted at a teammate (their turn, not yours).`,
-    `     - **A teammate replied within the last 60 seconds.** They are likely`,
-    `       already handling this turn; jumping in creates simultaneous replies`,
-    `       and confusion. Assume good faith and stay silent unless their reply`,
-    `       was clearly off-target.`,
-    `     - You have nothing substantive to add right now.`,
-    `   When in doubt, stay silent \u2014 over-replying creates noise. Better to let`,
-    `   the right teammate take the turn than to step on theirs.`,
-    ``,
-    `6. **If it's your turn \u2014 do the actual work, THEN reply-all about it.**`,
-    `   You have full native tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch,`,
-    `   WebSearch, NotebookEdit, etc. If the task is "implement X", write the file`,
-    `   with Write or Edit and verify with Bash \u2014 do NOT paste source code into an`,
-    `   email body and call it shipped. The thread is for COORDINATION ("done,`,
-    `   see ./foo.py, runs with \`python3 foo.py\`"); the filesystem is for`,
-    `   DELIVERABLES. Then:`,
-    `     reply_email({ uid: ${uid ?? "<uid>"}, replyAll: true, text: "...", _account: "${agent.name}" })`,
-    `   Sign with your name. Be substantive but concise. If you are handing off`,
-    `   to the next teammate, name them explicitly in your reply ("Orion \u2014 over to you, please \u2026").`,
-    `   **NAME the next actor in the \`wake\` parameter** so the dispatcher only`,
-    `   gives them a Claude turn \u2014 every other CC'd teammate still receives the`,
-    `   mail in their inbox but stays asleep, saving the project a lot of tokens.`,
-    `   Example: \`reply_email({ uid, replyAll: true, text: "Orion \u2014 your turn \u2026",`,
-    `   wake: ["orion"], _account: "${agent.name}" })\`. If nobody specific is`,
-    `   next (the work is complete and you're just signing off), pass \`wake: []\``,
-    `   to deliver silently with zero Claude turns spawned.`,
-    ``,
-    `7. **If you need additional help from a teammate not yet on the thread,**`,
-    `   include them by CC'ing in your reply-all \u2014 DO NOT spin up a separate`,
-    `   call_agent / message_agent side-channel. The thread is the workspace;`,
-    `   everyone stays in context.`,
-    ``,
-    `8. **If it's NOT your turn,** mark the message read with mark_read and return.`,
-    `   Do not reply just to acknowledge. Silence IS a valid contribution.`,
-    ``,
-    `## How threads end`,
-    ``,
-    `A thread is done when the host (or any participant) sends a wrap-up`,
-    `message with one of these markers in the subject: \`[FINAL]\`, \`[DONE]\`,`,
-    `\`[CLOSED]\`, \`[WRAP]\`. The dispatcher will stop waking workers on any`,
-    `further replies to that thread. If you are sending a wrap-up yourself`,
-    `(because the work is complete and no more contributions are needed),`,
-    `include one of those markers in your reply subject.`,
-    ``,
-    `When you finish, return a one-line summary of what you did:`,
-    `  "Contributed: <one-line description>"  OR  "Stayed silent \u2014 not my turn."`,
-    ``,
-    `## Fallback for non-thread mail`,
-    ``,
-    `If this is a fresh standalone email (not part of a thread, only addressed`,
-    `to you), handle it directly: answer the question, do the work, reply.`,
-    `Spam: trust the auto-filter unless something obviously slipped through.`
-  ].filter(Boolean).join("\n");
-}
-function taskPrompt(agent, event) {
-  const taskId = event.taskId ?? "(missing taskId)";
-  const taskText = event.task ?? "(no task description)";
-  const taskType = event.taskType ?? "generic";
-  const from = event.from ?? "unknown";
-  return [
-    `You have a pending task \u2014 handle it now.`,
-    ``,
-    `- Task ID: ${taskId}`,
-    `- Type: ${taskType}`,
-    `- From: ${from}`,
-    `- Task: ${taskText}`,
-    ``,
-    `Workflow:`,
-    `  1. Call claim_task({ id: "${taskId}", _account: "${agent.name}" }) to mark yourself as the owner.`,
-    `  2. Do the work using whatever pre-loaded or invoke-able MCP tools fit.`,
-    `  3. Call submit_result({ id: "${taskId}", result: { ... }, _account: "${agent.name}" }) with structured JSON.`,
-    `     The caller is waiting on a synchronous long-poll \u2014 submit_result is what wakes them.`,
-    ``,
-    `If you cannot complete the task, submit_result with { status: "failed", reason: "..." }. Never leave it unclaimed \u2014 that strands the caller until timeout.`
-  ].join("\n");
-}
-var Dispatcher = class {
-  cfg;
-  maxConcurrent;
-  syncIntervalMs;
-  reconnectBaseMs;
-  reconnectMaxMs;
-  query;
-  fetchImpl;
-  log;
-  channels = /* @__PURE__ */ new Map();
-  // keyed by account.id
-  accountSyncTimer = null;
-  systemChannelController = null;
-  running = 0;
-  waiters = [];
-  stopped = false;
-  /**
-   * Wake-budget store, keyed by `${accountId}::${threadId}`. See the
-   * comment block on WakeBudgetEntry for the failure modes this guards.
-   * Pruned opportunistically on each lookup — no separate timer.
-   */
-  wakeBudget = /* @__PURE__ */ new Map();
-  maxWakesPerThread;
-  wakeWindowMs;
-  now;
-  constructor(opts = {}) {
-    this.cfg = resolveConfig(opts);
-    this.maxConcurrent = opts.maxConcurrentWorkers ?? DEFAULT_MAX_CONCURRENT;
-    this.syncIntervalMs = opts.accountSyncIntervalMs ?? DEFAULT_SYNC_INTERVAL_MS;
-    this.reconnectBaseMs = opts.sseReconnectBaseMs ?? DEFAULT_RECONNECT_BASE_MS;
-    this.reconnectMaxMs = opts.sseReconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
-    this.query = opts.querySdk ?? defaultQuery();
-    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
-    this.log = opts.log ?? defaultLog;
-    this.maxWakesPerThread = opts.maxWakesPerThread ?? DEFAULT_MAX_WAKES_PER_THREAD;
-    this.wakeWindowMs = opts.wakeWindowMs ?? DEFAULT_WAKE_WINDOW_MS;
-    this.now = opts.nowMs ?? Date.now;
-    if (!this.cfg.masterKey) {
-      throw new Error("Dispatcher requires AgenticMail master key. Run `agenticmail setup` first.");
-    }
-  }
-  /**
-   * Charge one wake against the (agent, thread) budget. Returns true
-   * if the wake should proceed, false if the circuit breaker is open.
-   *
-   * Empty threadId means "no thread context" (a fresh standalone email
-   * with no Subject — rare); we always allow those since there is no
-   * thread to runaway on.
-   */
-  chargeWake(accountId, threadId) {
-    if (!threadId) return { ok: true };
-    const key = `${accountId}::${threadId}`;
-    const now = this.now();
-    let entry = this.wakeBudget.get(key);
-    if (entry && now - entry.firstWakeAtMs >= this.wakeWindowMs) {
-      entry = void 0;
-      this.wakeBudget.delete(key);
-    }
-    if (!entry) {
-      entry = { count: 1, firstWakeAtMs: now };
-      this.wakeBudget.set(key, entry);
-      this.maybePruneWakeBudget(now);
-      return { ok: true, count: 1 };
-    }
-    if (entry.count >= this.maxWakesPerThread) {
-      return {
-        ok: false,
-        count: entry.count,
-        mutedUntilMs: entry.firstWakeAtMs + this.wakeWindowMs
-      };
-    }
-    entry.count++;
-    return { ok: true, count: entry.count };
-  }
-  /**
-   * Drop wake-budget entries that have aged out of their window.
-   *
-   * Called inline from chargeWake, but at most once per ~1024 inserts so
-   * the cost stays bounded. We don't need a separate timer because the
-   * Map only grows on real wakes (capped by maxWakesPerThread per pair),
-   * and the prune is O(n) over the current entries — cheap enough.
-   */
-  wakeBudgetInsertsSinceLastPrune = 0;
-  maybePruneWakeBudget(now) {
-    this.wakeBudgetInsertsSinceLastPrune++;
-    if (this.wakeBudgetInsertsSinceLastPrune < 1024) return;
-    this.wakeBudgetInsertsSinceLastPrune = 0;
-    for (const [k, v] of this.wakeBudget) {
-      if (now - v.firstWakeAtMs >= this.wakeWindowMs) this.wakeBudget.delete(k);
-    }
-  }
-  async start() {
-    this.log("info", `[dispatcher] starting (maxConcurrent=${this.maxConcurrent}, syncEvery=${this.syncIntervalMs}ms)`);
-    await this.syncAccounts();
-    this.accountSyncTimer = setInterval(() => {
-      this.syncAccounts().catch((err) => this.log("warn", `[dispatcher] account sync failed: ${err}`));
-    }, this.syncIntervalMs);
-    void this.runSystemChannel();
-  }
-  async stop() {
-    this.stopped = true;
-    if (this.accountSyncTimer) clearInterval(this.accountSyncTimer);
-    this.accountSyncTimer = null;
-    if (this.systemChannelController) {
-      try {
-        this.systemChannelController.abort();
-      } catch {
-      }
-      this.systemChannelController = null;
-    }
-    for (const ch of this.channels.values()) {
-      ch.stopping = true;
-      ch.controller?.abort();
-    }
-    this.channels.clear();
-    this.log("info", "[dispatcher] stopped");
-  }
-  /** Public for tests — directly hand an event to the routing path. */
-  async handleEvent(account, event) {
-    if (this.stopped) return;
-    if (event.type === "new" && typeof event.uid === "number") {
-      const ch = this.channels.get(account.id);
-      if (ch?.seenUids.has(event.uid)) return;
-      const subject = extractSubject(event);
-      if (ch && Date.now() < ch.suppressTaskMailUntilMs && isTaskNotificationSubject(subject)) {
-        this.log("info", `[dispatcher] suppressed task-notification mail wake for "${account.name}" (uid=${event.uid}, subject="${subject}") \u2014 task event already dispatched`);
-        rememberBounded(ch.seenUids, event.uid);
-        return;
-      }
-      if (ch) rememberBounded(ch.seenUids, event.uid);
-      if (isThreadClosedSubject(subject)) {
-        this.log("info", `[dispatcher] thread closed (subject="${subject ?? ""}") \u2014 skipping wake for "${account.name}" uid=${event.uid}`);
-        return;
-      }
-      const allowlist = extractWakeAllowlist(event);
-      if (!isAgentOnWakeAllowlist(account.name, allowlist)) {
-        this.log("info", `[dispatcher] wake allowlist excludes "${account.name}" (list=${JSON.stringify(allowlist)}) \u2014 mail delivered, no Claude turn`);
-        return;
-      }
-      const threadId = threadIdFromSubject(subject);
-      const verdict = this.chargeWake(account.id, threadId);
-      if (!verdict.ok) {
-        const minutesUntil = verdict.mutedUntilMs ? Math.max(0, Math.round((verdict.mutedUntilMs - this.now()) / 6e4)) : 0;
-        this.log("warn", `[dispatcher] wake-budget exhausted for "${account.name}" on thread "${threadId}" (count=${verdict.count}, cap=${this.maxWakesPerThread}); muted for ~${minutesUntil}min. uid=${event.uid}, subject="${subject ?? ""}"`);
-        return;
-      }
-      await this.spawnWorker(account, newMailPrompt(account, event), {
-        kind: "new-mail",
-        uid: event.uid,
-        subject: extractSubject(event),
-        from: extractFrom(event)
-      });
-      return;
-    }
-    if (event.type === "task" && typeof event.taskId === "string") {
-      if (typeof event.assignee === "string" && event.assignee.toLowerCase() !== account.name.toLowerCase()) return;
-      const ch = this.channels.get(account.id);
-      if (ch?.seenTaskIds.has(event.taskId)) return;
-      if (ch) {
-        rememberBounded(ch.seenTaskIds, event.taskId);
-        ch.suppressTaskMailUntilMs = Date.now() + TASK_MAIL_SUPPRESS_WINDOW_MS;
-      }
-      await this.spawnWorker(account, taskPrompt(account, event), {
-        kind: "task",
-        taskId: event.taskId,
-        subject: typeof event.task === "string" ? event.task.slice(0, 120) : void 0,
-        from: typeof event.from === "string" ? event.from : void 0
-      });
-      return;
-    }
-  }
-  /**
-   * Should the dispatcher own a wake-channel for this account?
-   *
-   * We skip the bridge agent (default name "claudecode"). The bridge is
-   * the host session's own inbox proxy — when mail lands there, the
-   * HOST Claude Code session reads it via MCP (`list_inbox` /
-   * `wait_for_email` / `read_email`), NOT via a separately-spawned
-   * dispatcher worker. Spawning a worker for the bridge would:
-   *   1. Compete with the host (two Claude instances trying to "be"
-   *      Claude Code, both potentially replying autonomously).
-   *   2. Waste tokens — the host is already aware via its MCP polling.
-   *   3. Send the bridge into an autonomous loop if it ever replies-all
-   *      (because that mail would wake it again, ad infinitum).
-   *
-   * Role="bridge" is also skipped for symmetry with selectExposableAgents
-   * in install.ts — anything tagged as a bridge is host-managed.
-   */
-  shouldWatch(account) {
-    const bridgeName = this.cfg.bridgeAgentName.toLowerCase();
-    if (account.name.toLowerCase() === bridgeName) return false;
-    if (account.role === "bridge") return false;
-    return true;
-  }
-  /** Re-fetch /accounts; open SSE for new ones, close for vanished ones. */
-  async syncAccounts() {
-    let accounts;
-    try {
-      accounts = await listAccounts(this.cfg.apiUrl, this.cfg.masterKey);
-    } catch (err) {
-      this.log("warn", `[dispatcher] could not list accounts: ${err.message}`);
-      return;
-    }
-    accounts = accounts.filter((a) => this.shouldWatch(a));
-    const liveIds = new Set(accounts.map((a) => a.id));
-    for (const [id, ch] of this.channels) {
-      if (!liveIds.has(id)) {
-        ch.stopping = true;
-        ch.controller?.abort();
-        this.channels.delete(id);
-        this.log("info", `[dispatcher] account "${ch.account.name}" removed \u2014 closed SSE channel`);
-      }
-    }
-    for (const account of accounts) {
-      if (this.channels.has(account.id)) {
-        this.channels.get(account.id).account = account;
-        continue;
-      }
-      const ch = {
-        account,
-        controller: null,
-        stopping: false,
-        backoffMs: this.reconnectBaseMs,
-        seenUids: /* @__PURE__ */ new Set(),
-        seenTaskIds: /* @__PURE__ */ new Set(),
-        suppressTaskMailUntilMs: 0
-      };
-      this.channels.set(account.id, ch);
-      this.log("info", `[dispatcher] opening SSE for "${account.name}" (${account.email})`);
-      void this.runChannel(ch);
-    }
-  }
-  /**
-   * Subscribe to the API's master-scoped system events SSE.
-   *
-   * Pushes from /system/events arrive as JSON-per-frame just like the
-   * per-account stream:
-   *   { type: "connected" }
-   *   { type: "account_created", account: { id, name, email, apiKey, ... } }
-   *   { type: "account_deleted", accountId, name }
-   *
-   * On `account_created` we eagerly open a per-account SSE channel using
-   * the apiKey carried in the event payload — no extra round trip, the
-   * channel is live within milliseconds of the POST /accounts response.
-   *
-   * Reconnect with the same exponential backoff scheme as per-account
-   * channels. If the API is older and doesn't expose /system/events
-   * (404), we log once and stop trying — polling-only fallback still
-   * works.
-   */
-  async runSystemChannel() {
-    let backoff = this.reconnectBaseMs;
-    let giveUp = false;
-    while (!this.stopped && !giveUp) {
-      this.systemChannelController = new AbortController();
-      try {
-        const url = `${this.cfg.apiUrl.replace(/\/$/, "")}/api/agenticmail/system/events`;
-        const res = await this.fetchImpl(url, {
-          headers: {
-            "Authorization": `Bearer ${this.cfg.masterKey}`,
-            "Accept": "text/event-stream"
-          },
-          signal: this.systemChannelController.signal
-        });
-        if (res.status === 404) {
-          this.log("warn", "[dispatcher] /system/events not available on this API \u2014 falling back to polling-only account discovery (please upgrade @agenticmail/api to >=0.7.3)");
-          giveUp = true;
-          break;
-        }
-        if (!res.ok || !res.body) {
-          throw new Error(`system/events HTTP ${res.status}`);
-        }
-        backoff = this.reconnectBaseMs;
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (!this.stopped) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          let boundary;
-          while ((boundary = buffer.indexOf("\n\n")) !== -1) {
-            const frame = buffer.slice(0, boundary);
-            buffer = buffer.slice(boundary + 2);
-            for (const line of frame.split("\n")) {
-              if (!line.startsWith("data: ")) continue;
-              try {
-                const event = JSON.parse(line.slice(6));
-                this.handleSystemEvent(event);
-              } catch {
-              }
-            }
-          }
-        }
-      } catch (err) {
-        if (this.stopped) break;
-        this.log("warn", `[dispatcher] system-events stream error: ${err.message}; reconnecting in ${backoff}ms`);
-      }
-      if (this.stopped || giveUp) break;
-      await sleep(backoff);
-      backoff = Math.min(backoff * 2, this.reconnectMaxMs);
-    }
-  }
-  /** Apply an account-lifecycle event from /system/events. */
-  handleSystemEvent(event) {
-    const type = typeof event.type === "string" ? event.type : "";
-    if (type === "account_created" && event.account && typeof event.account === "object") {
-      const account = event.account;
-      if (!account.id || !account.name || !account.apiKey) {
-        this.log("warn", "[dispatcher] account_created event missing required fields; ignoring");
-        return;
-      }
-      if (!this.shouldWatch(account)) {
-        this.log("info", `[dispatcher] account_created "${account.name}" \u2014 skipping (bridge/role excluded)`);
-        return;
-      }
-      if (this.channels.has(account.id)) return;
-      const ch = {
-        account,
-        controller: null,
-        stopping: false,
-        backoffMs: this.reconnectBaseMs,
-        seenUids: /* @__PURE__ */ new Set(),
-        seenTaskIds: /* @__PURE__ */ new Set(),
-        suppressTaskMailUntilMs: 0
-      };
-      this.channels.set(account.id, ch);
-      this.log("info", `[dispatcher] account_created "${account.name}" (${account.email}) \u2014 opening SSE channel immediately`);
-      void this.runChannel(ch);
-      return;
-    }
-    if (type === "account_deleted" && typeof event.accountId === "string") {
-      const ch = this.channels.get(event.accountId);
-      if (!ch) return;
-      ch.stopping = true;
-      try {
-        ch.controller?.abort();
-      } catch {
-      }
-      this.channels.delete(event.accountId);
-      this.log("info", `[dispatcher] account_deleted "${ch.account.name}" \u2014 closed SSE channel`);
-      return;
-    }
-  }
-  /** Watch one account's SSE stream forever; reconnect with backoff on drop. */
-  async runChannel(ch) {
-    while (!ch.stopping && !this.stopped) {
-      try {
-        ch.controller = new AbortController();
-        await this.streamOne(ch);
-        if (!ch.stopping) {
-          this.log("warn", `[dispatcher] SSE for "${ch.account.name}" ended unexpectedly; reconnecting in ${ch.backoffMs}ms`);
-        }
-      } catch (err) {
-        if (ch.stopping) break;
-        this.log("warn", `[dispatcher] SSE error for "${ch.account.name}": ${err.message}; reconnecting in ${ch.backoffMs}ms`);
-      }
-      if (ch.stopping) break;
-      await sleep(ch.backoffMs);
-      ch.backoffMs = Math.min(ch.backoffMs * 2, this.reconnectMaxMs);
-    }
-  }
-  /** Single SSE attach. Returns when the stream closes for any reason. */
-  async streamOne(ch) {
-    const url = `${this.cfg.apiUrl.replace(/\/$/, "")}/api/agenticmail/events`;
-    const res = await this.fetchImpl(url, {
-      headers: {
-        "Authorization": `Bearer ${ch.account.apiKey}`,
-        "Accept": "text/event-stream"
-      },
-      signal: ch.controller.signal
-    });
-    if (!res.ok || !res.body) {
-      throw new Error(`SSE handshake HTTP ${res.status}`);
-    }
-    ch.backoffMs = this.reconnectBaseMs;
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (!ch.stopping) {
-      const { value, done } = await reader.read();
-      if (done) return;
-      buffer += decoder.decode(value, { stream: true });
-      let boundary;
-      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
-        const frame = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        for (const line of frame.split("\n")) {
-          if (!line.startsWith("data: ")) continue;
-          let event;
-          try {
-            event = JSON.parse(line.slice(6));
-          } catch {
-            continue;
-          }
-          this.handleEvent(ch.account, event).catch(
-            (err) => this.log("error", `[dispatcher] handleEvent threw for "${ch.account.name}": ${err}`)
-          );
-        }
-      }
-    }
-  }
-  /** Acquire a concurrency slot, run a worker, release the slot. */
-  async spawnWorker(account, prompt, ctx) {
-    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;
-    this.postActivity("/dispatcher/worker-started", {
-      workerId,
-      agentName: account.name,
-      agentEmail: account.email,
-      kind: ctx.kind,
-      trigger: { uid: ctx.uid, taskId: ctx.taskId, subject: ctx.subject, from: ctx.from }
-    });
-    const logsDir = join2(homedir(), ".agenticmail", "worker-logs");
-    try {
-      mkdirSync(logsDir, { recursive: true });
-    } catch {
-    }
-    const logPath = join2(logsDir, `${sanitizeId(workerId)}.log`);
-    let logStream = null;
-    try {
-      logStream = createWriteStream(logPath, { flags: "a" });
-    } catch {
-    }
-    const writeLog = (line) => {
-      try {
-        logStream?.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${line}
-`);
-      } catch {
-      }
-    };
-    writeLog(`worker_started agent=${account.name} kind=${ctx.kind}${ctx.uid ? " uid=" + ctx.uid : ""}${ctx.taskId ? " task=" + ctx.taskId : ""}`);
-    const cwdDir = join2(homedir(), ".agenticmail", "worker-cwds", sanitizeId(workerId));
-    try {
-      mkdirSync(cwdDir, { recursive: true });
-    } catch {
-    }
-    let turnCount = 0;
-    let lastTool = "";
-    const observer = {
-      onMessage: (tag, summary) => {
-        writeLog(`${tag} ${summary}`);
-        if (tag === "tool_use") {
-          lastTool = summary.split(" ")[0];
-          turnCount++;
-        }
-      }
-    };
-    const heartbeatHandle = setInterval(() => {
-      this.postActivity("/dispatcher/worker-heartbeat", {
-        workerId,
-        agentName: account.name,
-        lastTool: lastTool || void 0,
-        turnCount
-      });
-    }, 3e4);
-    heartbeatHandle.unref?.();
-    try {
-      const { body } = loadPersonaForAgent({
-        agent: account,
-        agentsDir: this.cfg.agentsDir,
-        subagentPrefix: this.cfg.subagentPrefix,
-        mcpServerName: this.cfg.mcpServerName
-      });
-      this.log("info", `[dispatcher] waking "${account.name}" \u2014 ${ctx.kind}${ctx.taskId ? " " + ctx.taskId : ctx.uid ? " uid=" + ctx.uid : ""}`);
-      const mcpEnv = await this.buildMcpEnv();
-      workerResult = await runWorker(
-        this.query,
-        body,
-        prompt,
-        account,
-        this.cfg.mcpServerName,
-        this.cfg.mcpCommand,
-        this.cfg.mcpArgs,
-        mcpEnv,
-        this.log,
-        void 0,
-        observer,
-        cwdDir
-      );
-    } finally {
-      clearInterval(heartbeatHandle);
-      this.releaseSlot();
-      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}`);
-      try {
-        logStream?.end();
-      } catch {
-      }
-      try {
-        rmSync(cwdDir, { recursive: true, force: true });
-      } catch {
-      }
-      this.postActivity("/dispatcher/worker-finished", {
-        workerId,
-        agentName: account.name,
-        ok,
-        turnCount,
-        resultPreview: typeof preview === "string" ? preview.slice(0, 240) : void 0
-      });
-    }
-  }
-  /**
-   * Fire-and-forget POST to the API's worker-activity endpoints.
-   *
-   * Failures are swallowed deliberately — the dispatcher must never
-   * block worker spawn or interrupt teardown because the API is briefly
-   * unreachable. The activity registry is best-effort observability, not
-   * load-bearing state.
-   */
-  postActivity(path, body) {
-    const url = `${this.cfg.apiUrl.replace(/\/$/, "")}/api/agenticmail${path}`;
-    try {
-      const result = this.fetchImpl(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.cfg.masterKey}`
-        },
-        body: JSON.stringify(body)
-      });
-      if (result && typeof result.catch === "function") {
-        void result.catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  /** Build the env block we pass to the worker's MCP server child process. */
-  async buildMcpEnv() {
-    return {
-      AGENTICMAIL_API_URL: this.cfg.apiUrl,
-      AGENTICMAIL_MASTER_KEY: this.cfg.masterKey
-      // No AGENTICMAIL_API_KEY: workers should ALWAYS pass `_account`
-      // explicitly. Omitting the default key forces that discipline at
-      // the MCP-server level (any forgotten `_account` becomes a clear
-      // error rather than a silent identity drift).
-    };
-  }
-  acquireSlot() {
-    if (this.running < this.maxConcurrent) {
-      this.running++;
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      this.waiters.push(() => {
-        this.running++;
-        resolve();
-      });
-    });
-  }
-  releaseSlot() {
-    this.running--;
-    const next = this.waiters.shift();
-    if (next) next();
-  }
-};
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function sanitizeId(id) {
-  return id.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function defaultLog(level, msg) {
-  const stream = level === "error" ? process.stderr : process.stdout;
-  stream.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${msg}
-`);
-}
-function defaultQuery() {
-  return (params) => {
-    let inner = null;
-    const init = async () => {
-      try {
-        const mod = await import("@anthropic-ai/claude-agent-sdk");
-        return mod.query(params);
-      } catch (err) {
-        throw new Error(
-          `Dispatcher needs @anthropic-ai/claude-agent-sdk installed in the package, but: ${err.message}`
-        );
-      }
-    };
-    return {
-      [Symbol.asyncIterator]() {
-        return {
-          async next() {
-            if (!inner) inner = await init();
-            const it = inner[Symbol.asyncIterator]();
-            const self = this;
-            self.next = it.next.bind(it);
-            return it.next();
-          }
-        };
-      }
-    };
-  };
-}
-
-export {
-  loadPersonaForAgent,
-  Dispatcher
-};