agent-inbox 0.2.4 → 0.2.5

package/rules/agent-inbox.md

@@ -60,7 +60,6 @@ read_thread({ threadTag: "deploy-v2" })
 - `"bob"` — local agent on this system
 - `"bob@system-2"` — agent on a federated remote system
 - `"@system-2"` — broadcast to all agents on a remote system
-- `"person@example.com"` — an external email address (only when email interop is enabled for that domain; otherwise the send is rejected). Replies from that person arrive back in your inbox like any other message, and threading is preserved.
 
 ## Discovering other agents
 

package/src/federation/connection-manager.ts

@@ -59,8 +59,6 @@ export class ConnectionManager {
   private meshConnector: MeshConnector | null;
   private meshPeer: MeshPeerLike | null;
   private onIncoming: IncomingMessageHandler | null;
-  /** Optional predicate marking recipients owned by the mail gateway (skipped). */
-  private mailFilter: ((agentId: string) => boolean) | null = null;
   readonly routing: RoutingEngine;
   readonly queue: DeliveryQueue;
   readonly trust: TrustManager;
@@ -112,15 +110,6 @@ export class ConnectionManager {
     return this.systemId;
   }
 
-  /**
-   * Register a predicate identifying recipients handled by the mail gateway.
-   * Those recipients are skipped by route() so a `bob@example.com` address is
-   * not mistaken for a federation peer.
-   */
-  setMailRecipientFilter(fn: (agentId: string) => boolean): void {
-    this.mailFilter = fn;
-  }
-
   /**
    * Establish federation with a peer. Uses MAP federation/connect protocol.
    * If an SDK class was injected, opens a real MAP connection to the peer.
@@ -275,7 +264,6 @@ export class ConnectionManager {
   async route(message: Message): Promise<DeliveryResult> {
     // Determine target for each recipient
     for (const recipient of message.recipients) {
-      if (this.mailFilter?.(recipient.agent_id)) continue; // handled by mail gateway
       const addr = parseAddress(recipient.agent_id);
       if (!isRemoteAddress(addr)) continue;
 

package/src/federation/delivery-queue.ts

@@ -1,7 +1,6 @@
 import { EventEmitter } from "node:events";
 import { ulid } from "ulid";
 import type { Message, DeliveryQueueConfig, QueuedMessage } from "../types.js";
-import type { QueueStore } from "./queue-store.js";
 
 const DEFAULT_CONFIG: DeliveryQueueConfig = {
   persistence: "memory",
@@ -17,37 +16,19 @@ const DEFAULT_CONFIG: DeliveryQueueConfig = {
 /**
  * Delivery queue for messages to offline or unreachable federation peers.
  *
- * Supports configurable TTL, overflow policy, and retry strategy. Keeps an
- * in-memory index for fast reads; when a durable QueueStore is supplied, every
- * mutation is write-through journaled and the index is hydrated from the store
- * on construction so queued messages survive a restart.
+ * Supports configurable TTL, overflow policy, and retry strategy.
+ * Currently memory-only; SQLite persistence is a future enhancement.
  */
 export class DeliveryQueue {
   private queues = new Map<string, QueuedMessage[]>();
   private config: DeliveryQueueConfig;
   private tickTimer?: ReturnType<typeof setInterval>;
-  private store: QueueStore | null;
 
   constructor(
     private events: EventEmitter,
-    config?: Partial<DeliveryQueueConfig>,
-    opts?: { store?: QueueStore }
+    config?: Partial<DeliveryQueueConfig>
   ) {
     this.config = { ...DEFAULT_CONFIG, ...config };
-    this.store = opts?.store ?? null;
-    if (this.store) this.hydrate(this.store);
-  }
-
-  /** Load persisted entries into the in-memory index (durable mode). */
-  private hydrate(store: QueueStore): void {
-    for (const entry of store.loadAll()) {
-      let queue = this.queues.get(entry.peerId);
-      if (!queue) {
-        queue = [];
-        this.queues.set(entry.peerId, queue);
-      }
-      queue.push(entry);
-    }
   }
 
   /**
@@ -63,11 +44,9 @@ export class DeliveryQueue {
     // Check queue size limit
     if (queue.length >= this.config.maxQueueSize) {
       switch (this.config.overflow) {
-        case "drop-oldest": {
-          const dropped = queue.shift();
-          if (dropped) this.store?.remove(peerId, dropped.id);
+        case "drop-oldest":
+          queue.shift();
           break;
-        }
         case "drop-newest":
           return null; // Don't enqueue
         case "reject-new":
@@ -86,7 +65,6 @@ export class DeliveryQueue {
     };
 
     queue.push(entry);
-    this.store?.upsert(entry);
     this.events.emit("queue.enqueued", { peerId, messageId: entry.id });
     return entry.id;
   }
@@ -101,7 +79,6 @@ export class DeliveryQueue {
 
     const messages = [...queue];
     this.queues.delete(peerId);
-    this.store?.removePeer(peerId);
     this.events.emit("queue.flushed", { peerId, count: messages.length });
     return messages;
   }
@@ -146,7 +123,6 @@ export class DeliveryQueue {
         ? this.config.retryBaseInterval * Math.pow(2, entry.attempts - 1)
         : this.config.retryBaseInterval;
     entry.nextRetry = new Date(Date.now() + delay).toISOString();
-    this.store?.upsert(entry);
     return true;
   }
 
@@ -161,7 +137,6 @@ export class DeliveryQueue {
     if (idx === -1) return false;
 
     queue.splice(idx, 1);
-    this.store?.remove(peerId, messageId);
     if (queue.length === 0) this.queues.delete(peerId);
     return true;
   }
@@ -175,15 +150,10 @@ export class DeliveryQueue {
 
     for (const [peerId, queue] of this.queues.entries()) {
       const before = queue.length;
-      const remaining: QueuedMessage[] = [];
-      for (const entry of queue) {
+      const remaining = queue.filter((entry) => {
         const age = now - new Date(entry.enqueuedAt).getTime();
-        if (age < this.config.maxTTL) {
-          remaining.push(entry);
-        } else {
-          this.store?.remove(peerId, entry.id);
-        }
-      }
+        return age < this.config.maxTTL;
+      });
       expired += before - remaining.length;
 
       if (remaining.length === 0) {

package/src/index.ts

@@ -16,14 +16,6 @@ import { DeliveryBridge } from "./mesh/delivery-bridge.js";
 import type { MeshContextLike } from "./mesh/mesh-transport.js";
 import type { MeshPeerLike, MeshMapServer } from "./map/map-client.js";
 import { WarmRegistry } from "./registry/warm-registry.js";
-import { MailGateway } from "./mail/mail-gateway.js";
-import { SmtpTransport } from "./mail/smtp-transport.js";
-import { PostmarkTransport } from "./mail/provider-transport.js";
-import type { MailTransport } from "./mail/types.js";
-import { SqliteAttachmentStore } from "./mail/attachment-store.js";
-import { FsAttachmentStore } from "./mail/fs-attachment-store.js";
-import { SqliteQueueStore } from "./federation/queue-store.js";
-import { findDomainConflicts } from "./router/destination.js";
 import type { InboxConfig } from "./types.js";
 import type { Storage } from "./storage/interface.js";
 
@@ -70,52 +62,6 @@ export type { MeshDeliveryHandler } from "./mesh/delivery-bridge.js";
 export { mapMessageToInbox, inboxMessageToMap } from "./mesh/type-mapper.js";
 export type { MapMessage as MeshMapMessage, MapAddress as MeshMapAddress } from "./mesh/type-mapper.js";
 export type { MeshPeerLike, MeshAgentConnection, MeshMapServer } from "./map/map-client.js";
-// Mail interop
-export { MailGateway, RateLimitedError } from "./mail/mail-gateway.js";
-export type { MailGatewayConfig } from "./mail/mail-gateway.js";
-export { RateLimiter } from "./mail/rate-limiter.js";
-export { SmtpTransport, parseDsnFromParsed } from "./mail/smtp-transport.js";
-export type { SmtpTransportOptions } from "./mail/smtp-transport.js";
-export {
-  PostmarkTransport,
-  outboundToPostmark,
-  postmarkInboundToMail,
-  postmarkBounceToInbound,
-  postmarkResponseToResult,
-  postmarkErrorToResult,
-} from "./mail/provider-transport.js";
-export type {
-  PostmarkTransportOptions,
-  PostmarkClient,
-  PostmarkInbound,
-  PostmarkBounce,
-} from "./mail/provider-transport.js";
-export { AddressBook } from "./mail/address-book.js";
-export { SqliteAttachmentStore } from "./mail/attachment-store.js";
-export { FsAttachmentStore } from "./mail/fs-attachment-store.js";
-export {
-  inboundMailToMessage,
-  messageToOutboundMail,
-  UnknownRecipientError,
-} from "./mail/email-mapper.js";
-export {
-  classifyDestination,
-  UnknownDestinationError,
-  domainMatches,
-  findDomainConflicts,
-} from "./router/destination.js";
-export type { Destination, DestinationContext } from "./router/destination.js";
-export type {
-  MailTransport,
-  MailCapabilities,
-  OutboundMail,
-  InboundMail,
-  MailSendResult,
-  InboundBounce,
-  InboundAuthResults,
-  AttachmentStore,
-} from "./mail/types.js";
-export type { MailEgress } from "./router/message-router.js";
 export type * from "./types.js";
 export type { Storage, InboxQuery, ThreadQuery } from "./storage/interface.js";
 
@@ -157,7 +103,6 @@ export interface AgentInbox {
   notifier: PushNotifier;
   federation: ConnectionManager | null;
   registry: WarmRegistry | null;
-  mail: MailGateway | null;
   events: EventEmitter;
   stop(): Promise<void>;
 }
@@ -383,97 +328,6 @@ export async function createAgentInbox(
     federation.queue.startTicking();
   }
 
-  // 7b. Mail interop (inbound + outbound email)
-  let mail: MailGateway | null = null;
-  if (config.mail?.enabled) {
-    const mailConfig = config.mail;
-
-    // Surface domains claimed by both a federation peer and mail config —
-    // federation wins (see classifyDestination), but operators should know.
-    const mailDomains = [
-      ...mailConfig.identity.localDomains,
-      ...(mailConfig.routableDomains ?? []),
-    ];
-    const domainConflicts = findDomainConflicts({
-      isLocalAgent: () => false,
-      federationPeers: config.federation?.peers ?? [],
-      mailDomains,
-    });
-    if (domainConflicts.length > 0) {
-      events.emit("mail.config.conflict", {
-        kind: "domain",
-        conflicts: domainConflicts,
-      });
-      console.error(
-        `Mail config warning: domain(s) claimed by both federation and mail — federation wins: ${domainConflicts.join(", ")}`
-      );
-    }
-
-    // Durable queue + attachment storage when backed by SQLite.
-    const db =
-      storage instanceof SqliteStorage ? storage.getDatabase() : undefined;
-    const queueStore = db ? new SqliteQueueStore(db) : undefined;
-
-    // Attachment storage: filesystem (opt-in) or SQLite BLOBs (default).
-    let attachmentStore: SqliteAttachmentStore | FsAttachmentStore | undefined;
-    if (mailConfig.attachments?.backend === "fs") {
-      const dir =
-        mailConfig.attachments.dir ??
-        path.join(os.homedir(), ".claude", "agent-inbox", "attachments");
-      attachmentStore = new FsAttachmentStore(dir);
-    } else if (db) {
-      attachmentStore = new SqliteAttachmentStore(db);
-    }
-
-    const transport: MailTransport =
-      mailConfig.backend === "provider"
-        ? new PostmarkTransport({
-            serverToken: mailConfig.provider?.apiKeyRef,
-            webhook: mailConfig.provider?.webhookPath
-              ? { port: 0, inboundPath: mailConfig.provider.webhookPath }
-              : undefined,
-            attachmentStore,
-          })
-        : new SmtpTransport({
-            listenPort: mailConfig.smtp?.listenPort,
-            relay: mailConfig.smtp?.relay,
-            dkim: mailConfig.smtp?.dkim
-              ? {
-                  domainName: mailConfig.smtp.dkim.domain,
-                  keySelector: mailConfig.smtp.dkim.selector,
-                  privateKey: mailConfig.smtp.dkim.privateKeyRef,
-                }
-              : undefined,
-            attachmentStore,
-          });
-
-    mail = new MailGateway({
-      transport,
-      storage,
-      router,
-      events,
-      queueStore,
-      config: {
-        identity: mailConfig.identity,
-        routableDomains: mailConfig.routableDomains,
-        allowedSenderDomains: mailConfig.allowedSenderDomains,
-        rejectDmarcFail: mailConfig.rejectDmarcFail,
-        maxAttachments: mailConfig.maxAttachments,
-        rateLimit: mailConfig.rateLimit,
-        bounce: mailConfig.bounce,
-        defaultScope: config.scope,
-        queue: mailConfig.queue,
-      },
-    });
-
-    router.setMail(mail);
-    federation?.setMailRecipientFilter((id) => mail!.ownsRecipient(id));
-    await mail.start();
-    console.error(
-      `Mail interop enabled (${mailConfig.backend}) for domains: ${mailConfig.identity.localDomains.join(", ")}`
-    );
-  }
-
   // 8. JSON-RPC server (mail/* methods)
   const jsonRpc = new MailJsonRpcServer(storage, router, events);
   if (opts.httpPort && opts.httpPort > 0) {
@@ -509,7 +363,6 @@ export async function createAgentInbox(
     if (retentionTimer) clearInterval(retentionTimer);
     await ipcServer.stop();
     await jsonRpc.stopHttp();
-    if (mail) await mail.stop();
     await mapClient.disconnect();
     if (federation) await federation.destroy();
     if (registry) registry.destroy();
@@ -528,7 +381,6 @@ export async function createAgentInbox(
     notifier,
     federation,
     registry,
-    mail,
     events,
     stop,
   };

package/src/jsonrpc/mail-push-types.ts

@@ -13,7 +13,12 @@
  * @module agent-inbox/jsonrpc/mail-push-types
  */
 
-import type { Turn, ContentType, MessageContent } from "../types.js";
+import type {
+  Turn,
+  ContentType,
+  MessageContent,
+  Conversation,
+} from "../types.js";
 
 /**
  * The canonical JSON-RPC method name for server-pushed turn delivery.
@@ -47,14 +52,38 @@ export interface MailTurnReceivedParams {
    * `"low"` | `"normal"` | `"high"` | `"urgent"`
    */
   importance?: string;
+
+  /**
+   * Optional parent-conversation context. Populated when the fan-out site
+   * can resolve the turn's conversation (see `resolveConversation` in
+   * {@link MailPushBridgeConfig}). Lets receivers filter/route the push —
+   * e.g. "is a local agent a participant?", "is this a spec-thread vs a
+   * dispatch delivery channel?" — without a round-trip back to the hub.
+   * Omitted when the fan-out site only has the turn in scope.
+   */
+  conversation?: {
+    scope: string;
+    subject?: string;
+    metadata?: Record<string, unknown>;
+    /** Participant agent ids (roles omitted; use `mail/presence` for detail). */
+    participants?: string[];
+  };
 }
 
 /**
  * Build a `MailTurnReceivedParams` payload from a stored {@link Turn}.
  * Centralizes field-mapping so consumers can't drift from the canonical
  * shape.
+ *
+ * When `conversation` is supplied, its scope/subject/metadata/participant
+ * ids are folded into an optional `conversation` block so receivers can
+ * filter/route without a round-trip. Omit it to send turn fields only
+ * (backward-compatible with pre-0.2.4 receivers).
  */
-export function buildMailTurnReceivedParams(turn: Turn): MailTurnReceivedParams {
+export function buildMailTurnReceivedParams(
+  turn: Turn,
+  conversation?: Conversation
+): MailTurnReceivedParams {
   return {
     conversation_id: turn.conversation_id,
     turn_id: turn.id,
@@ -64,5 +93,17 @@ export function buildMailTurnReceivedParams(turn: Turn): MailTurnReceivedParams
     ...(turn.thread_id ? { thread_id: turn.thread_id } : {}),
     created_at: turn.created_at,
     ...(turn.importance ? { importance: turn.importance } : {}),
+    ...(conversation
+      ? {
+          conversation: {
+            scope: conversation.scope,
+            ...(conversation.subject
+              ? { subject: conversation.subject }
+              : {}),
+            metadata: conversation.metadata,
+            participants: conversation.participants.map((p) => p.agent_id),
+          },
+        }
+      : {}),
   };
 }

package/src/jsonrpc/mail-push.ts

@@ -22,7 +22,7 @@
  */
 
 import type { EventEmitter } from "node:events";
-import type { Turn } from "../types.js";
+import type { Turn, Conversation } from "../types.js";
 import {
   MAIL_TURN_RECEIVED_METHOD,
   buildMailTurnReceivedParams,
@@ -76,6 +76,18 @@ export interface MailPushBridgeConfig<
     params: MailTurnReceivedParams,
   ) => void | Promise<void>;
 
+  /**
+   * Optional resolver for the turn's parent conversation. When provided,
+   * the resolved conversation's scope/subject/metadata/participants are
+   * folded into the notification `params.conversation` block so receivers
+   * can filter/route without a round-trip back to the hub. Return
+   * `undefined` to omit context for a given turn (the notification still
+   * carries all turn fields). Kept as an injected resolver rather than a
+   * storage dependency so the factory stays transport- and
+   * storage-agnostic.
+   */
+  resolveConversation?: (turn: Turn) => Conversation | undefined;
+
   /** Optional logger. Defaults to console.log. */
   log?: (msg: string) => void;
 }
@@ -93,7 +105,13 @@ export interface MailPushBridge {
 export function createMailPushBridge<
   TSubscriber extends MailPushSubscriber = MailPushSubscriber,
 >(config: MailPushBridgeConfig<TSubscriber>): MailPushBridge {
-  const { mailEvents, getSubscribers, sendNotification, log = () => {} } = config;
+  const {
+    mailEvents,
+    getSubscribers,
+    sendNotification,
+    resolveConversation,
+    log = () => {},
+  } = config;
 
   const onTurnAdded = (turn: unknown): void => {
     if (!turn || typeof turn !== "object") return;
@@ -116,7 +134,20 @@ export function createMailPushBridge<
 
     if (subscribers.length === 0) return;
 
-    const params = buildMailTurnReceivedParams(t);
+    let conversation: Conversation | undefined;
+    if (resolveConversation) {
+      try {
+        conversation = resolveConversation(t);
+      } catch (err) {
+        // Non-fatal: fall back to a context-less notification rather than
+        // dropping the turn. Receivers degrade to a hub round-trip.
+        log(
+          `[mail-push] resolveConversation threw for turn ${t.id}: ${(err as Error).message}`,
+        );
+      }
+    }
+
+    const params = buildMailTurnReceivedParams(t, conversation);
 
     for (const subscriber of subscribers) {
       try {

package/src/jsonrpc/mail-server.ts

@@ -56,11 +56,24 @@ export class MailJsonRpcServer {
   }
 
   private registerMethods(): void {
-    // mail/create — create a conversation
+    // mail/create — create a conversation (create-or-get)
+    //
+    // When an explicit `id` is supplied and already exists, return the
+    // existing conversation untouched instead of overwriting it. Callers
+    // use `mail/create` as an idempotent lazy factory by passing a
+    // deterministic id (dispatch threads, spec threads); because
+    // `putConversation` is a destructive upsert that re-syncs participants
+    // from the passed object (built here with `participants: []`), a blind
+    // re-create would silently wipe participants and overwrite metadata.
     this.methods.set("mail/create", (params) => {
+      const explicitId = params.id as string | undefined;
+      if (explicitId) {
+        const existing = this.storage.getConversation(explicitId);
+        if (existing) return existing;
+      }
       const now = new Date().toISOString();
       const conv: Conversation = {
-        id: (params.id as string) ?? `conv-${ulid()}`,
+        id: explicitId ?? `conv-${ulid()}`,
         scope: (params.scope as string) ?? "default",
         subject: params.subject as string | undefined,
         status: "active",
@@ -120,19 +133,25 @@ export class MailJsonRpcServer {
     });
 
     // mail/join — add self as participant
+    //
+    // Uses the storage `addParticipant` helper (atomic INSERT OR IGNORE)
+    // rather than read-modify-write via `putConversation`, which rewrites
+    // the entire participant list and can drop a concurrent join/invite.
     this.methods.set("mail/join", (params) => {
-      const conv = this.storage.getConversation(
-        params.conversationId as string
-      );
+      const conversationId = params.conversationId as string;
+      const conv = this.storage.getConversation(conversationId);
       if (!conv) throw rpcError(-32001, "Conversation not found");
       const agentId = params.agentId as string;
-      if (!conv.participants.some((p) => p.agent_id === agentId)) {
-        conv.participants.push({
+      const alreadyMember = conv.participants.some(
+        (p) => p.agent_id === agentId
+      );
+      if (!alreadyMember) {
+        const now = new Date().toISOString();
+        this.storage.addParticipant(conversationId, {
           agent_id: agentId,
-          joined_at: new Date().toISOString(),
+          joined_at: now,
         });
-        conv.updated_at = new Date().toISOString();
-        this.storage.putConversation(conv);
+        this.storage.touchConversation(conversationId, now);
         this.events.emit("mail.participant.joined", {
           conversation_id: conv.id,
           agent_id: agentId,
@@ -143,34 +162,34 @@ export class MailJsonRpcServer {
 
     // mail/leave — remove self from conversation
     this.methods.set("mail/leave", (params) => {
-      const conv = this.storage.getConversation(
-        params.conversationId as string
-      );
+      const conversationId = params.conversationId as string;
+      const conv = this.storage.getConversation(conversationId);
       if (!conv) throw rpcError(-32001, "Conversation not found");
       const agentId = params.agentId as string;
-      conv.participants = conv.participants.filter(
-        (p) => p.agent_id !== agentId
-      );
-      conv.updated_at = new Date().toISOString();
-      this.storage.putConversation(conv);
+      this.storage.removeParticipant(conversationId, agentId);
+      this.storage.touchConversation(conversationId, new Date().toISOString());
       return { ok: true };
     });
 
     // mail/invite — add agent to conversation
+    //
+    // Same atomic-add rationale as mail/join; carries an optional role.
     this.methods.set("mail/invite", (params) => {
-      const conv = this.storage.getConversation(
-        params.conversationId as string
-      );
+      const conversationId = params.conversationId as string;
+      const conv = this.storage.getConversation(conversationId);
       if (!conv) throw rpcError(-32001, "Conversation not found");
       const agentId = params.agentId as string;
-      if (!conv.participants.some((p) => p.agent_id === agentId)) {
-        conv.participants.push({
+      const alreadyMember = conv.participants.some(
+        (p) => p.agent_id === agentId
+      );
+      if (!alreadyMember) {
+        const now = new Date().toISOString();
+        this.storage.addParticipant(conversationId, {
           agent_id: agentId,
           role: params.role as string | undefined,
-          joined_at: new Date().toISOString(),
+          joined_at: now,
         });
-        conv.updated_at = new Date().toISOString();
-        this.storage.putConversation(conv);
+        this.storage.touchConversation(conversationId, now);
         this.events.emit("mail.participant.joined", {
           conversation_id: conv.id,
           agent_id: agentId,

package/src/router/message-router.ts

@@ -11,17 +11,6 @@ import type { Storage } from "../storage/interface.js";
 import type { ConnectionManager } from "../federation/connection-manager.js";
 import { parseAddress, isRemoteAddress } from "../federation/address.js";
 
-/**
- * Outbound mail sink. Implemented by MailGateway; kept as a local interface so
- * the router does not depend on the mail module (avoids a cycle).
- */
-export interface MailEgress {
-  /** True if this recipient's domain is one the mail gateway routes for. */
-  ownsRecipient(agentId: string): boolean;
-  /** Render and deliver the mail-class recipients of a message. */
-  send(message: Message): Promise<void>;
-}
-
 export interface SendOptions {
   from: string;
   to: string | string[] | { agent_id: string; kind?: RecipientKind }[];
@@ -37,7 +26,6 @@ export interface SendOptions {
 
 export class MessageRouter {
   private federation: ConnectionManager | null = null;
-  private mail: MailEgress | null = null;
 
   constructor(
     private storage: Storage,
@@ -52,13 +40,6 @@ export class MessageRouter {
     this.federation = federation;
   }
 
-  /**
-   * Attach a mail gateway for routing to external email recipients.
-   */
-  setMail(mail: MailEgress): void {
-    this.mail = mail;
-  }
-
   async routeMessage(opts: SendOptions): Promise<Message> {
     const recipients = this.resolveRecipients(opts.to);
     const content = normalizeContent(opts.payload);
@@ -91,11 +72,8 @@ export class MessageRouter {
       created_at: now,
     };
 
-    // Classify recipients: mail (external email) takes precedence over the
-    // federation interpretation of "agent@domain"; remaining remote recipients
-    // go to federation; everything else local.
+    // Mark local recipients as delivered; route remote ones via federation
     for (const r of message.recipients) {
-      if (this.mail?.ownsRecipient(r.agent_id)) continue; // mail — see below
       const addr = parseAddress(r.agent_id);
       if (!isRemoteAddress(addr) && this.isLocal(r.agent_id)) {
         r.delivered_at = now;
@@ -113,25 +91,10 @@ export class MessageRouter {
 
     this.events.emit("message.created", message);
 
-    // Route external mail recipients via the mail gateway.
-    if (this.mail) {
-      const hasMail = message.recipients.some((r) =>
-        this.mail!.ownsRecipient(r.agent_id)
-      );
-      if (hasMail) {
-        // Fire-and-forget; transient failures are queued inside the gateway.
-        this.mail.send(message).catch(() => {
-          // Mail delivery failures are handled by the gateway's retry queue
-        });
-      }
-    }
-
-    // Route remaining remote recipients via federation (excluding mail).
+    // Route remote recipients via federation
     if (this.federation) {
-      const hasRemote = message.recipients.some(
-        (r) =>
-          isRemoteAddress(parseAddress(r.agent_id)) &&
-          !this.mail?.ownsRecipient(r.agent_id)
+      const hasRemote = message.recipients.some((r) =>
+        isRemoteAddress(parseAddress(r.agent_id))
       );
       if (hasRemote) {
         // Fire-and-forget federation routing (results tracked via events)