@agenticmail/api 0.5.58 → 0.5.60

package/dist/index.js

@@ -264,17 +264,17 @@ function createAccountRoutes(accountManager, db, config) {
   const router = Router2();
   const deletionService = new AgentDeletionService(db, accountManager, config);
   router.post("/accounts", requireMaster, async (req, res, next) => {
+    if (!req.body || typeof req.body !== "object") {
+      res.status(400).json({ error: "Request body must be JSON" });
+      return;
+    }
+    const { name: accountName, domain, password, metadata, role, persistent } = req.body;
     try {
-      if (!req.body || typeof req.body !== "object") {
-        res.status(400).json({ error: "Request body must be JSON" });
-        return;
-      }
-      const { name: name2, domain, password, metadata, role, persistent } = req.body;
-      if (!name2 || typeof name2 !== "string") {
+      if (!accountName || typeof accountName !== "string") {
         res.status(400).json({ error: "name is required and must be a string" });
         return;
       }
-      if (name2.length > 64) {
+      if (accountName.length > 64) {
         res.status(400).json({ error: "name must be 64 characters or fewer" });
         return;
       }
@@ -293,7 +293,7 @@ function createAccountRoutes(accountManager, db, config) {
       const cleanMeta = metadata ? Object.fromEntries(
         Object.entries(metadata).filter(([k]) => !k.startsWith("_"))
       ) : void 0;
-      const agent = await accountManager.create({ name: name2, domain, password: password || void 0, metadata: cleanMeta, role });
+      const agent = await accountManager.create({ name: accountName, domain, password: password || void 0, metadata: cleanMeta, role });
       try {
         db.prepare("UPDATE agents SET last_activity_at = datetime('now') WHERE id = ?").run(agent.id);
       } catch {
@@ -310,7 +310,7 @@ function createAccountRoutes(accountManager, db, config) {
     } catch (err) {
       const msg = err.message ?? "";
       if (msg.includes("UNIQUE") || msg.includes("unique") || msg.includes("already exists") || msg.includes("duplicate") || msg.includes("fieldAlreadyExists") || msg.toLowerCase().includes("alreadyexists")) {
-        res.status(409).json({ error: `Agent "${name}" already exists` });
+        res.status(409).json({ error: "Account already exists", name: accountName });
         return;
       }
       next(err);
@@ -488,996 +488,916 @@ function createAccountRoutes(accountManager, db, config) {
 }
 
 // src/routes/mail.ts
-import { Router as Router3 } from "express";
+import { Router as Router5 } from "express";
 import crypto from "crypto";
 import {
-  MailSender,
+  MailSender as MailSender2,
+  MailReceiver as MailReceiver2,
+  parseEmail as parseEmail2,
+  scoreEmail as scoreEmail2,
+  sanitizeEmail,
+  isInternalEmail as isInternalEmail2,
+  scanOutboundEmail
+} from "@agenticmail/core";
+
+// src/routes/events.ts
+import { Router as Router4 } from "express";
+import {
+  InboxWatcher,
   MailReceiver,
   parseEmail,
   scoreEmail,
-  sanitizeEmail,
   isInternalEmail,
-  scanOutboundEmail
+  classifyEmailRoute
 } from "@agenticmail/core";
-var senderCache = /* @__PURE__ */ new Map();
-var receiverCache = /* @__PURE__ */ new Map();
-var receiverPending = /* @__PURE__ */ new Map();
-var CACHE_TTL_MS = 10 * 60 * 1e3;
-var MAX_CACHE_SIZE = 100;
-var draining = false;
-function getAgentPassword(agent) {
-  return agent.metadata?._password || agent.name;
-}
-var evictionTimer = null;
-function startEvictionTimer() {
-  if (evictionTimer) return;
-  evictionTimer = setInterval(evictStaleEntries, 6e4);
-}
-function evictStaleEntries() {
-  const now = Date.now();
-  for (const [key, entry] of senderCache) {
-    if (now - entry.createdAt > CACHE_TTL_MS) {
-      try {
-        entry.sender.close();
-      } catch {
-      }
-      senderCache.delete(key);
-    }
+import { v4 as uuidv42 } from "uuid";
+
+// src/routes/features.ts
+import { Router as Router3 } from "express";
+import { v4 as uuidv4 } from "uuid";
+import {
+  MailSender
+} from "@agenticmail/core";
+function parseScheduleTime(input) {
+  const trimmed = input.trim();
+  if (/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(trimmed)) {
+    const d = new Date(trimmed);
+    return isNaN(d.getTime()) ? null : d;
   }
-  for (const [key, entry] of receiverCache) {
-    if (now - entry.createdAt > CACHE_TTL_MS) {
-      entry.receiver.disconnect().catch(() => {
-      });
-      receiverCache.delete(key);
-    }
+  const lower = trimmed.toLowerCase();
+  const relativeMatch = lower.match(/^in\s+(\d+)\s+(minute|minutes|min|mins|hour|hours|hr|hrs|day|days)$/);
+  if (relativeMatch) {
+    const amount = parseInt(relativeMatch[1], 10);
+    const unit = relativeMatch[2];
+    const now = Date.now();
+    if (unit.startsWith("min")) return new Date(now + amount * 6e4);
+    if (unit.startsWith("h")) return new Date(now + amount * 36e5);
+    if (unit.startsWith("d")) return new Date(now + amount * 864e5);
   }
-}
-function getSender(authUser, fromEmail, password, config) {
-  if (draining) throw new Error("Server is shutting down");
-  const cacheKey = `${authUser}:${fromEmail}`;
-  const cached = senderCache.get(cacheKey);
-  if (cached) return cached.sender;
-  if (senderCache.size >= MAX_CACHE_SIZE) {
-    const oldest = senderCache.keys().next().value;
-    if (oldest) {
-      try {
-        senderCache.get(oldest)?.sender.close();
-      } catch {
+  const tomorrowMatch = lower.match(/^tomorrow\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
+  if (tomorrowMatch) {
+    const tomorrow = /* @__PURE__ */ new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    let hour = parseInt(tomorrowMatch[1], 10);
+    const min = tomorrowMatch[2] ? parseInt(tomorrowMatch[2], 10) : 0;
+    const ampm = tomorrowMatch[3];
+    if (ampm === "pm" && hour !== 12) hour += 12;
+    if (ampm === "am" && hour === 12) hour = 0;
+    tomorrow.setHours(hour, min, 0, 0);
+    return tomorrow;
+  }
+  const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+  const nextDayMatch = lower.match(/^next\s+(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
+  if (nextDayMatch) {
+    const targetDay = dayNames.indexOf(nextDayMatch[1]);
+    let hour = parseInt(nextDayMatch[2], 10);
+    const min = nextDayMatch[3] ? parseInt(nextDayMatch[3], 10) : 0;
+    const ampm = nextDayMatch[4];
+    if (ampm === "pm" && hour !== 12) hour += 12;
+    if (ampm === "am" && hour === 12) hour = 0;
+    const result = /* @__PURE__ */ new Date();
+    const currentDay = result.getDay();
+    let daysUntil = targetDay - currentDay;
+    if (daysUntil <= 0) daysUntil += 7;
+    result.setDate(result.getDate() + daysUntil);
+    result.setHours(hour, min, 0, 0);
+    return result;
+  }
+  if (lower === "tonight" || lower === "this evening") {
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(20, 0, 0, 0);
+    if (d.getTime() <= Date.now()) d.setDate(d.getDate() + 1);
+    return d;
+  }
+  const humanMatch = trimmed.match(
+    /^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})\s+(\d{1,2}):(\d{2})\s*(AM|PM|am|pm)\s*(.+)?$/
+  );
+  if (humanMatch) {
+    const [, mStr, dStr, yStr, hStr, minStr, ampmRaw, tzRaw] = humanMatch;
+    const month = parseInt(mStr, 10);
+    const day = parseInt(dStr, 10);
+    const year = parseInt(yStr, 10);
+    let hour = parseInt(hStr, 10);
+    const min = parseInt(minStr, 10);
+    const ampm = ampmRaw.toUpperCase();
+    if (month < 1 || month > 12 || day < 1 || day > 31 || hour < 1 || hour > 12) return null;
+    if (ampm === "PM" && hour !== 12) hour += 12;
+    if (ampm === "AM" && hour === 12) hour = 0;
+    const result = new Date(year, month - 1, day, hour, min, 0, 0);
+    if (tzRaw?.trim()) {
+      const TZ_OFFSETS = {
+        EST: -5,
+        EDT: -4,
+        CST: -6,
+        CDT: -5,
+        MST: -7,
+        MDT: -6,
+        PST: -8,
+        PDT: -7,
+        GMT: 0,
+        UTC: 0,
+        BST: 1,
+        CET: 1,
+        CEST: 2,
+        IST: 5.5,
+        JST: 9,
+        AEST: 10,
+        AEDT: 11,
+        NZST: 12,
+        NZDT: 13,
+        WAT: 1,
+        EAT: 3,
+        SAST: 2,
+        HKT: 8,
+        SGT: 8,
+        KST: 9,
+        HST: -10,
+        AKST: -9,
+        AKDT: -8,
+        AST: -4,
+        ADT: -3,
+        NST: -3.5,
+        NDT: -2.5
+      };
+      const tz = tzRaw.trim().toUpperCase();
+      if (TZ_OFFSETS[tz] !== void 0) {
+        const tzOffsetMs = TZ_OFFSETS[tz] * 36e5;
+        const serverOffsetMs = result.getTimezoneOffset() * -6e4;
+        const diff = serverOffsetMs - tzOffsetMs;
+        result.setTime(result.getTime() + diff);
       }
-      senderCache.delete(oldest);
     }
+    return isNaN(result.getTime()) ? null : result;
   }
-  const sender = new MailSender({
-    host: config.smtp.host,
-    port: config.smtp.port,
-    email: fromEmail,
-    password,
-    authUser
-  });
-  senderCache.set(cacheKey, { sender, createdAt: Date.now() });
-  startEvictionTimer();
-  return sender;
+  const fallback = new Date(trimmed);
+  return isNaN(fallback.getTime()) ? null : fallback;
 }
-async function getReceiver(authUser, password, config) {
-  if (draining) throw new Error("Server is shutting down");
-  const cached = receiverCache.get(authUser);
-  if (cached) {
+function createFeatureRoutes(db, _accountManager, config, gatewayManager) {
+  const router = Router3();
+  router.get("/contacts", requireAgent, async (req, res, next) => {
     try {
-      const client = cached.receiver.getImapClient();
-      if (client.usable) return cached.receiver;
-    } catch {
+      const rows = db.prepare("SELECT * FROM contacts WHERE agent_id = ? ORDER BY name, email").all(req.agent.id);
+      res.json({ contacts: rows });
+    } catch (err) {
+      next(err);
     }
+  });
+  router.post("/contacts", requireAgent, async (req, res, next) => {
     try {
-      await cached.receiver.disconnect();
-    } catch {
-    }
-    receiverCache.delete(authUser);
-  }
-  const pending = receiverPending.get(authUser);
-  if (pending) return pending;
-  const promise = createReceiver(authUser, password, config);
-  receiverPending.set(authUser, promise);
-  try {
-    return await promise;
-  } finally {
-    receiverPending.delete(authUser);
-  }
-}
-async function createReceiver(authUser, password, config) {
-  if (receiverCache.size >= MAX_CACHE_SIZE) {
-    const oldest = receiverCache.keys().next().value;
-    if (oldest) {
-      receiverCache.get(oldest)?.receiver.disconnect().catch(() => {
-      });
-      receiverCache.delete(oldest);
+      const { name, email, notes } = req.body || {};
+      if (!email) {
+        res.status(400).json({ error: "email is required" });
+        return;
+      }
+      const id = uuidv4();
+      db.prepare("INSERT OR REPLACE INTO contacts (id, agent_id, name, email, notes) VALUES (?, ?, ?, ?, ?)").run(id, req.agent.id, name || null, email, notes || null);
+      res.json({ ok: true, id, email });
+    } catch (err) {
+      next(err);
     }
-  }
-  const receiver = new MailReceiver({
-    host: config.imap.host,
-    port: config.imap.port,
-    email: authUser,
-    password
   });
-  try {
-    await receiver.connect();
-  } catch (err) {
+  router.delete("/contacts/:id", requireAgent, async (req, res, next) => {
     try {
-      await receiver.disconnect();
-    } catch {
+      const result = db.prepare("DELETE FROM contacts WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Contact not found" });
+        return;
+      }
+      res.json({ ok: true });
+    } catch (err) {
+      next(err);
     }
-    throw err;
-  }
-  receiverCache.set(authUser, { receiver, createdAt: Date.now() });
-  startEvictionTimer();
-  return receiver;
-}
-async function closeCaches() {
-  draining = true;
-  if (evictionTimer) {
-    clearInterval(evictionTimer);
-    evictionTimer = null;
-  }
-  for (const [, entry] of senderCache) {
+  });
+  router.get("/drafts", requireAgent, async (req, res, next) => {
     try {
-      entry.sender.close();
-    } catch {
+      const rows = db.prepare("SELECT * FROM drafts WHERE agent_id = ? ORDER BY updated_at DESC").all(req.agent.id);
+      res.json({ drafts: rows });
+    } catch (err) {
+      next(err);
     }
-  }
-  senderCache.clear();
-  for (const [, entry] of receiverCache) {
+  });
+  router.post("/drafts", requireAgent, async (req, res, next) => {
     try {
-      await entry.receiver.disconnect();
-    } catch {
+      const { to, subject, text, html, cc, bcc, inReplyTo, references } = req.body || {};
+      const id = uuidv4();
+      db.prepare(`INSERT INTO drafts (id, agent_id, to_addr, subject, text_body, html_body, cc, bcc, in_reply_to, refs)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+        id,
+        req.agent.id,
+        to || null,
+        subject || null,
+        text || null,
+        html || null,
+        cc || null,
+        bcc || null,
+        inReplyTo || null,
+        references ? JSON.stringify(references) : null
+      );
+      res.json({ ok: true, id });
+    } catch (err) {
+      next(err);
     }
-  }
-  receiverCache.clear();
-}
-function saveSentCopy(authUser, password, config, raw) {
-  (async () => {
+  });
+  router.put("/drafts/:id", requireAgent, async (req, res, next) => {
     try {
-      const receiver = await getReceiver(authUser, password, config);
-      await receiver.appendMessage(raw, "Sent Items", ["\\Seen"]);
+      const { to, subject, text, html, cc, bcc, inReplyTo, references } = req.body || {};
+      const result = db.prepare(`UPDATE drafts SET to_addr=?, subject=?, text_body=?, html_body=?,
+        cc=?, bcc=?, in_reply_to=?, refs=?, updated_at=datetime('now')
+        WHERE id=? AND agent_id=?`).run(
+        to || null,
+        subject || null,
+        text || null,
+        html || null,
+        cc || null,
+        bcc || null,
+        inReplyTo || null,
+        references ? JSON.stringify(references) : null,
+        req.params.id,
+        req.agent.id
+      );
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Draft not found" });
+        return;
+      }
+      res.json({ ok: true });
     } catch (err) {
-      console.warn(`[mail] Failed to save Sent copy for ${authUser}: ${err.message}`);
+      next(err);
     }
-  })();
-}
-function createMailRoutes(accountManager, config, db, gatewayManager) {
-  const router = Router3();
-  router.post("/mail/send", requireAgent, async (req, res, next) => {
+  });
+  router.delete("/drafts/:id", requireAgent, async (req, res, next) => {
     try {
-      if (!req.body || typeof req.body !== "object") {
-        res.status(400).json({ error: "Request body must be JSON" });
+      const result = db.prepare("DELETE FROM drafts WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Draft not found" });
         return;
       }
-      const agent = req.agent;
-      const { to, subject, text, html, cc, bcc, replyTo, inReplyTo, references, attachments, allowSensitive } = req.body;
-      if (!to || !subject) {
-        res.status(400).json({ error: "to and subject are required" });
+      res.json({ ok: true });
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.post("/drafts/:id/send", requireAgent, async (req, res, next) => {
+    try {
+      const draft = db.prepare("SELECT * FROM drafts WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
+      if (!draft) {
+        res.status(404).json({ error: "Draft not found" });
         return;
       }
-      if (typeof to !== "string" && !Array.isArray(to)) {
-        res.status(400).json({ error: "to must be a string or array of strings" });
+      if (!draft.to_addr) {
+        res.status(400).json({ error: "Draft has no recipient" });
         return;
       }
-      let outboundWarnings;
-      let outboundSummary;
-      if (!(allowSensitive && req.isMaster)) {
-        const scanResult = scanOutboundEmail({
-          to: Array.isArray(to) ? to.join(", ") : to,
-          subject,
-          text,
-          html,
-          attachments: Array.isArray(attachments) ? attachments.map((a) => ({
-            filename: a.filename || "",
-            contentType: a.contentType,
-            content: a.content,
-            encoding: a.encoding
-          })) : void 0
-        });
-        if (scanResult.blocked) {
-          const pendingId = crypto.randomUUID();
-          const ownerName2 = agent.metadata?.ownerName;
-          const fromName2 = ownerName2 ? `${agent.name} from ${ownerName2}` : agent.name;
-          const mailOptions = { to, subject, text, html, cc, bcc, replyTo, inReplyTo, references, attachments, fromName: fromName2 };
-          db.prepare(
-            `INSERT INTO pending_outbound (id, agent_id, mail_options, warnings, summary) VALUES (?, ?, ?, ?, ?)`
-          ).run(pendingId, agent.id, JSON.stringify(mailOptions), JSON.stringify(scanResult.warnings), scanResult.summary);
-          if (gatewayManager) {
-            const ownerEmail = gatewayManager.getConfig()?.relay?.email;
-            if (ownerEmail) {
-              const warningList = scanResult.warnings.map((w) => `  - [${w.severity.toUpperCase()}] ${w.ruleId}: ${w.description}${w.match ? ` (matched: ${w.match})` : ""}`).join("\n");
-              const recipientLine = Array.isArray(to) ? to.join(", ") : to;
-              const emailPreview = [
-                "\u2500".repeat(50),
-                `From: ${fromName2} <${agent.email}>`,
-                `To: ${recipientLine}`
-              ];
-              if (cc) emailPreview.push(`CC: ${Array.isArray(cc) ? cc.join(", ") : cc}`);
-              if (bcc) emailPreview.push(`BCC: ${Array.isArray(bcc) ? bcc.join(", ") : bcc}`);
-              emailPreview.push(`Subject: ${subject}`);
-              if (Array.isArray(attachments) && attachments.length > 0) {
-                const attNames = attachments.map((a) => a.filename || "unnamed").join(", ");
-                emailPreview.push(`Attachments: ${attNames}`);
-              }
-              emailPreview.push("\u2500".repeat(50));
-              if (text) emailPreview.push("", text);
-              else if (html) emailPreview.push("", "[HTML content \u2014 see original for formatted version]");
-              else emailPreview.push("", "[No body content]");
-              emailPreview.push("\u2500".repeat(50));
-              gatewayManager.routeOutbound(agent.name, {
-                to: ownerEmail,
-                subject: `[Approval Required] Blocked email from "${agent.name}" \u2014 "${subject}"`,
-                text: [
-                  `Your agent "${agent.name}" attempted to send an email that was blocked by the outbound security guard.`,
-                  "",
-                  "SECURITY WARNINGS:",
-                  warningList,
-                  "",
-                  "FULL EMAIL FOR REVIEW:",
-                  ...emailPreview,
-                  "",
-                  `Pending ID: ${pendingId}`,
-                  "",
-                  "ACTION REQUIRED:",
-                  'Reply "approve" to this email to send it, or "reject" to discard it.',
-                  "If you do not respond, the agent will follow up with you."
-                ].join("\n"),
-                fromName: "Agentic Mail"
-              }).then((result2) => {
-                if (result2?.messageId) {
-                  db.prepare("UPDATE pending_outbound SET notification_message_id = ? WHERE id = ?").run(result2.messageId, pendingId);
-                }
-              }).catch(() => {
-              });
-            }
-          }
-          res.json({
-            sent: false,
-            blocked: true,
-            pendingId,
-            warnings: scanResult.warnings,
-            summary: scanResult.summary
-          });
-          return;
-        }
-        if (scanResult.warnings.length > 0) {
-          outboundWarnings = scanResult.warnings;
-          outboundSummary = scanResult.summary;
-        }
-      }
-      const ownerName = agent.metadata?.ownerName;
-      const fromName = ownerName ? `${agent.name} from ${ownerName}` : agent.name;
-      const mailOpts = { to, subject, text, html, cc, bcc, replyTo, inReplyTo, references, attachments, fromName };
-      const password = getAgentPassword(agent);
+      const agent = req.agent;
+      const mailOpts = {
+        to: draft.to_addr,
+        subject: draft.subject || "(no subject)",
+        text: draft.text_body || void 0,
+        html: draft.html_body || void 0,
+        cc: draft.cc || void 0,
+        bcc: draft.bcc || void 0,
+        inReplyTo: draft.in_reply_to || void 0,
+        references: draft.refs ? JSON.parse(draft.refs) : void 0
+      };
       if (gatewayManager) {
         const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
         if (gatewayResult) {
-          if (gatewayResult.raw) {
-            saveSentCopy(agent.stalwartPrincipal, password, config, gatewayResult.raw);
-          }
-          const { raw: _raw2, ...response2 } = gatewayResult;
-          res.json({ ...response2, ...outboundWarnings ? { outboundWarnings, outboundSummary } : {} });
+          db.prepare("DELETE FROM drafts WHERE id = ?").run(draft.id);
+          res.json(gatewayResult);
           return;
         }
       }
-      const sender = getSender(agent.stalwartPrincipal, agent.email, password, config);
-      const result = await sender.send(mailOpts);
-      saveSentCopy(agent.stalwartPrincipal, password, config, result.raw);
-      const { raw: _raw, ...response } = result;
-      res.json({ ...response, ...outboundWarnings ? { outboundWarnings, outboundSummary } : {} });
+      const password = getAgentPassword(agent);
+      const sender = new MailSender({
+        host: config.smtp.host,
+        port: config.smtp.port,
+        email: agent.email,
+        password,
+        authUser: agent.stalwartPrincipal
+      });
+      try {
+        const result = await sender.send(mailOpts);
+        db.prepare("DELETE FROM drafts WHERE id = ?").run(draft.id);
+        res.json(result);
+      } finally {
+        sender.close();
+      }
     } catch (err) {
       next(err);
     }
   });
-  router.get("/mail/inbox", requireAgent, async (req, res, next) => {
+  router.get("/signatures", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 200);
-      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const mailboxInfo = await receiver.getMailboxInfo("INBOX");
-      const envelopes = await receiver.listEnvelopes("INBOX", { limit, offset });
-      res.json({ messages: envelopes, count: envelopes.length, total: mailboxInfo.exists });
+      const rows = db.prepare("SELECT * FROM signatures WHERE agent_id = ? ORDER BY is_default DESC, name").all(req.agent.id);
+      res.json({ signatures: rows });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/mail/messages/:uid", requireAgent, async (req, res, next) => {
+  router.post("/signatures", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
+      const { name, text, html, isDefault } = req.body || {};
+      if (!name) {
+        res.status(400).json({ error: "name is required" });
         return;
       }
-      const folder = req.query.folder || "INBOX";
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const raw = await receiver.fetchMessage(uid, folder);
-      const parsed = await parseEmail(raw);
-      if (isInternalEmail(parsed)) {
-        res.json({
-          ...parsed,
-          security: { internal: true, spamScore: 0, isSpam: false, isWarning: false }
-        });
-        return;
+      const id = uuidv4();
+      if (isDefault) {
+        db.prepare("UPDATE signatures SET is_default = 0 WHERE agent_id = ?").run(req.agent.id);
       }
-      const sanitized = sanitizeEmail(parsed);
-      const spamScore = scoreEmail(parsed);
-      res.json({
-        ...parsed,
-        text: sanitized.text,
-        html: sanitized.html,
-        security: {
-          spamScore: spamScore.score,
-          isSpam: spamScore.isSpam,
-          isWarning: spamScore.isWarning,
-          topCategory: spamScore.topCategory,
-          matches: spamScore.matches.map((m) => m.ruleId),
-          sanitized: sanitized.wasModified,
-          sanitizeDetections: sanitized.detections
-        }
-      });
+      db.prepare("INSERT OR REPLACE INTO signatures (id, agent_id, name, text_content, html_content, is_default) VALUES (?, ?, ?, ?, ?, ?)").run(id, req.agent.id, name, text || null, html || null, isDefault ? 1 : 0);
+      res.json({ ok: true, id });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/mail/messages/:uid/attachments/:index", requireAgent, async (req, res, next) => {
+  router.delete("/signatures/:id", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      const index = parseInt(req.params.index);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
-        return;
-      }
-      if (isNaN(index) || index < 0) {
-        res.status(400).json({ error: "Invalid attachment index" });
-        return;
-      }
-      const folder = req.query.folder || "INBOX";
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const raw = await receiver.fetchMessage(uid, folder);
-      const parsed = await parseEmail(raw);
-      if (!parsed.attachments || index >= parsed.attachments.length) {
-        res.status(404).json({ error: "Attachment not found" });
+      const result = db.prepare("DELETE FROM signatures WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Signature not found" });
         return;
       }
-      const att = parsed.attachments[index];
-      res.setHeader("Content-Type", att.contentType || "application/octet-stream");
-      res.setHeader("Content-Disposition", `attachment; filename="${att.filename.replace(/"/g, '\\"')}"`);
-      res.setHeader("Content-Length", att.content.length);
-      res.send(att.content);
+      res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/search", requireAgent, async (req, res, next) => {
+  router.get("/templates", requireAgent, async (req, res, next) => {
     try {
-      if (!req.body || typeof req.body !== "object") {
-        res.status(400).json({ error: "Request body must be JSON" });
-        return;
-      }
-      const agent = req.agent;
-      const { from, to, subject, since, before, seen, text, searchRelay } = req.body;
-      const password = getAgentPassword(agent);
-      const sinceDate = since ? new Date(since) : void 0;
-      const beforeDate = before ? new Date(before) : void 0;
-      if (sinceDate && isNaN(sinceDate.getTime())) {
-        res.status(400).json({ error: 'Invalid "since" date' });
+      const rows = db.prepare("SELECT * FROM templates WHERE agent_id = ? ORDER BY name").all(req.agent.id);
+      res.json({ templates: rows });
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.post("/templates", requireAgent, async (req, res, next) => {
+    try {
+      const { name, subject, text, html } = req.body || {};
+      if (!name) {
+        res.status(400).json({ error: "name is required" });
         return;
       }
-      if (beforeDate && isNaN(beforeDate.getTime())) {
-        res.status(400).json({ error: 'Invalid "before" date' });
+      const id = uuidv4();
+      db.prepare("INSERT OR REPLACE INTO templates (id, agent_id, name, subject, text_body, html_body) VALUES (?, ?, ?, ?, ?, ?)").run(id, req.agent.id, name, subject || null, text || null, html || null);
+      res.json({ ok: true, id });
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.delete("/templates/:id", requireAgent, async (req, res, next) => {
+    try {
+      const result = db.prepare("DELETE FROM templates WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Template not found" });
         return;
       }
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const uids = await receiver.search({
-        from,
-        to,
-        subject,
-        since: sinceDate,
-        before: beforeDate,
-        seen,
-        text
-      });
-      let relayResults;
-      if (searchRelay === true && gatewayManager) {
-        try {
-          const relayHits = await gatewayManager.searchRelay({
-            from,
-            to,
-            subject,
-            text,
-            since: sinceDate,
-            before: beforeDate,
-            seen
-          });
-          if (relayHits.length > 0) {
-            relayResults = relayHits.map((r) => ({
-              uid: r.uid,
-              source: r.source,
-              account: r.account,
-              messageId: r.messageId,
-              subject: r.subject,
-              from: r.from,
-              to: r.to,
-              date: r.date,
-              flags: r.flags
-            }));
-          }
-        } catch {
-        }
-      }
-      res.json({ uids, ...relayResults ? { relayResults } : {} });
+      res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/import-relay", requireAgent, async (req, res, next) => {
+  router.get("/scheduled", requireAgent, async (req, res, next) => {
     try {
-      const { uid } = req.body || {};
-      if (!uid || typeof uid !== "number" || uid < 1) {
-        res.status(400).json({ error: "uid (number) is required" });
+      const rows = db.prepare("SELECT * FROM scheduled_emails WHERE agent_id = ? ORDER BY send_at ASC").all(req.agent.id);
+      res.json({ scheduled: rows });
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.post("/scheduled", requireAgent, async (req, res, next) => {
+    try {
+      const { to, subject, text, html, cc, bcc, sendAt } = req.body || {};
+      if (!to || !subject || !sendAt) {
+        res.status(400).json({ error: "to, subject, and sendAt are required" });
         return;
       }
-      if (!gatewayManager) {
-        res.status(400).json({ error: "No gateway configured" });
+      const sendDate = parseScheduleTime(String(sendAt));
+      if (!sendDate || isNaN(sendDate.getTime())) {
+        res.status(400).json({
+          error: "Invalid sendAt date. Accepted formats: ISO 8601 (2026-02-14T10:00:00), presets (in 30 minutes, in 1 hour, in 3 hours, tomorrow 8am, tomorrow 9am, next monday 9am), or MM-DD-YYYY H:MM AM/PM TZ"
+        });
         return;
       }
-      const agent = req.agent;
-      const result = await gatewayManager.importRelayMessage(uid, agent.name);
-      if (!result.success) {
-        res.status(400).json({ error: result.error || "Import failed" });
+      if (sendDate.getTime() <= Date.now()) {
+        res.status(400).json({ error: "sendAt must be in the future" });
         return;
       }
-      res.json({ ok: true, message: "Email imported to local inbox. Use /inbox or list_inbox to see it." });
+      const id = uuidv4();
+      db.prepare(`INSERT INTO scheduled_emails (id, agent_id, to_addr, subject, text_body, html_body, cc, bcc, send_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, req.agent.id, to, subject, text || null, html || null, cc || null, bcc || null, sendDate.toISOString());
+      res.json({ ok: true, id, sendAt: sendDate.toISOString() });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/messages/:uid/seen", requireAgent, async (req, res, next) => {
+  router.delete("/scheduled/:id", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
+      const result = db.prepare("DELETE FROM scheduled_emails WHERE id = ? AND agent_id = ? AND status = 'pending'").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Scheduled email not found or already sent" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.markSeen(uid);
       res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/mail/messages/:uid", requireAgent, async (req, res, next) => {
+  router.get("/tags", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
+      const rows = db.prepare("SELECT * FROM tags WHERE agent_id = ? ORDER BY name").all(req.agent.id);
+      res.json({ tags: rows });
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.post("/tags", requireAgent, async (req, res, next) => {
+    try {
+      const { name, color } = req.body || {};
+      if (!name) {
+        res.status(400).json({ error: "name is required" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.deleteMessage(uid);
-      res.status(204).send();
+      const id = uuidv4();
+      db.prepare("INSERT OR IGNORE INTO tags (id, agent_id, name, color) VALUES (?, ?, ?, ?)").run(id, req.agent.id, name.trim(), color || "#888888");
+      res.json({ ok: true, id, name: name.trim(), color: color || "#888888" });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/messages/:uid/unseen", requireAgent, async (req, res, next) => {
+  router.delete("/tags/:id", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
+      const result = db.prepare("DELETE FROM tags WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Tag not found" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.markUnseen(uid);
       res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/messages/:uid/move", requireAgent, async (req, res, next) => {
+  router.post("/tags/:id/messages", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
+      const { uid, folder } = req.body || {};
+      if (!uid) {
+        res.status(400).json({ error: "uid is required" });
         return;
       }
-      const { from: fromFolder, to: toFolder } = req.body || {};
-      if (!toFolder) {
-        res.status(400).json({ error: "to (destination folder) is required" });
+      const tag = db.prepare("SELECT * FROM tags WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
+      if (!tag) {
+        res.status(404).json({ error: "Tag not found" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.moveMessage(uid, fromFolder || "INBOX", toFolder);
+      db.prepare("INSERT OR IGNORE INTO message_tags (agent_id, message_uid, tag_id, folder) VALUES (?, ?, ?, ?)").run(req.agent.id, uid, req.params.id, folder || "INBOX");
       res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/mail/folders", requireAgent, async (req, res, next) => {
+  router.delete("/tags/:id/messages/:uid", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const folders = await receiver.listFolders();
-      res.json({ folders });
+      const folder = req.query.folder || "INBOX";
+      db.prepare("DELETE FROM message_tags WHERE agent_id = ? AND message_uid = ? AND tag_id = ? AND folder = ?").run(req.agent.id, parseInt(String(req.params.uid)), req.params.id, folder);
+      res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/folders", requireAgent, async (req, res, next) => {
+  router.get("/tags/:id/messages", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const { name: name2 } = req.body || {};
-      if (!name2 || typeof name2 !== "string" || !name2.trim()) {
-        res.status(400).json({ error: "name is required" });
-        return;
-      }
-      if (name2.length > 200 || /[\\*%]/.test(name2)) {
-        res.status(400).json({ error: "Invalid folder name" });
+      const tag = db.prepare("SELECT * FROM tags WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
+      if (!tag) {
+        res.status(404).json({ error: "Tag not found" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.createFolder(name2);
-      res.json({ ok: true, folder: name2 });
+      const rows = db.prepare(
+        "SELECT message_uid, folder FROM message_tags WHERE agent_id = ? AND tag_id = ? ORDER BY created_at DESC"
+      ).all(req.agent.id, req.params.id);
+      res.json({ tag, messages: rows.map((r) => ({ uid: r.message_uid, folder: r.folder })) });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/mail/folders/:folder", requireAgent, async (req, res, next) => {
+  router.get("/messages/:uid/tags", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const folder = decodeURIComponent(req.params.folder);
-      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 200);
-      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      let mailboxInfo;
-      try {
-        mailboxInfo = await receiver.getMailboxInfo(folder);
-      } catch {
-        res.json({ messages: [], count: 0, total: 0, folder });
-        return;
-      }
-      const envelopes = await receiver.listEnvelopes(folder, { limit, offset });
-      res.json({ messages: envelopes, count: envelopes.length, total: mailboxInfo.exists, folder });
+      const rows = db.prepare(`
+        SELECT t.* FROM tags t
+        JOIN message_tags mt ON mt.tag_id = t.id
+        WHERE mt.agent_id = ? AND mt.message_uid = ?
+        ORDER BY t.name
+      `).all(req.agent.id, parseInt(String(req.params.uid)));
+      res.json({ tags: rows });
     } catch (err) {
       next(err);
     }
   });
-  function validateUids(raw) {
-    if (!Array.isArray(raw) || raw.length === 0) return null;
-    if (raw.length > 1e3) return null;
-    const nums = raw.map(Number).filter((n) => Number.isInteger(n) && n > 0);
-    return nums.length > 0 ? nums : null;
-  }
-  router.post("/mail/batch/delete", requireAgent, async (req, res, next) => {
+  router.post("/templates/:id/send", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const { uids: rawUids, folder } = req.body || {};
-      const uids = validateUids(rawUids);
-      if (!uids) {
-        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
+      const template = db.prepare("SELECT * FROM templates WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
+      if (!template) {
+        res.status(404).json({ error: "Template not found" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.batchDelete(uids, folder || "INBOX");
-      res.json({ ok: true, deleted: uids.length });
-    } catch (err) {
-      next(err);
-    }
-  });
-  router.post("/mail/batch/seen", requireAgent, async (req, res, next) => {
-    try {
-      const agent = req.agent;
-      const { uids: rawUids, folder } = req.body || {};
-      const uids = validateUids(rawUids);
-      if (!uids) {
-        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
+      const { to, variables, cc, bcc } = req.body || {};
+      if (!to) {
+        res.status(400).json({ error: "to is required" });
         return;
       }
+      const applyVars = (text, vars2) => text.replace(/\{\{(\w+)\}\}/g, (m, key) => vars2[key] ?? m);
+      const vars = variables && typeof variables === "object" ? variables : {};
+      const mailOpts = {
+        to,
+        subject: applyVars(template.subject || "(no subject)", vars),
+        text: template.text_body ? applyVars(template.text_body, vars) : void 0,
+        html: template.html_body ? applyVars(template.html_body, vars) : void 0,
+        cc: cc || void 0,
+        bcc: bcc || void 0
+      };
+      const agent = req.agent;
+      if (gatewayManager) {
+        const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
+        if (gatewayResult) {
+          res.json(gatewayResult);
+          return;
+        }
+      }
       const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.batchMarkSeen(uids, folder || "INBOX");
-      res.json({ ok: true, marked: uids.length });
+      const sender = new MailSender({
+        host: config.smtp.host,
+        port: config.smtp.port,
+        email: agent.email,
+        password,
+        authUser: agent.stalwartPrincipal
+      });
+      try {
+        const result = await sender.send(mailOpts);
+        res.json(result);
+      } finally {
+        sender.close();
+      }
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/batch/unseen", requireAgent, async (req, res, next) => {
+  router.get("/rules", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const { uids: rawUids, folder } = req.body || {};
-      const uids = validateUids(rawUids);
-      if (!uids) {
-        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
-        return;
-      }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.batchMarkUnseen(uids, folder || "INBOX");
-      res.json({ ok: true, marked: uids.length });
+      const rows = db.prepare("SELECT * FROM email_rules WHERE agent_id = ? ORDER BY priority DESC, created_at").all(req.agent.id);
+      res.json({ rules: rows.map((r) => ({ ...r, conditions: JSON.parse(r.conditions), actions: JSON.parse(r.actions) })) });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/batch/move", requireAgent, async (req, res, next) => {
+  router.post("/rules", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const { uids: rawUids, from: fromFolder, to: toFolder } = req.body || {};
-      const uids = validateUids(rawUids);
-      if (!uids) {
-        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
-        return;
-      }
-      if (!toFolder) {
-        res.status(400).json({ error: "to (destination folder) is required" });
+      const { name, conditions, actions, priority, enabled } = req.body || {};
+      if (!name) {
+        res.status(400).json({ error: "name is required" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.batchMove(uids, fromFolder || "INBOX", toFolder);
-      res.json({ ok: true, moved: uids.length });
+      const id = uuidv4();
+      db.prepare(
+        "INSERT INTO email_rules (id, agent_id, name, priority, enabled, conditions, actions) VALUES (?, ?, ?, ?, ?, ?, ?)"
+      ).run(id, req.agent.id, name, priority ?? 0, enabled !== false ? 1 : 0, JSON.stringify(conditions || {}), JSON.stringify(actions || {}));
+      res.status(201).json({ id, name, conditions: conditions || {}, actions: actions || {}, priority: priority ?? 0, enabled: enabled !== false });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/mail/batch/read", requireAgent, async (req, res, next) => {
+  router.delete("/rules/:id", requireAgent, async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const { uids: rawUids, folder } = req.body || {};
-      const uids = validateUids(rawUids);
-      if (!uids) {
-        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
+      const result = db.prepare("DELETE FROM email_rules WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
+      if (result.changes === 0) {
+        res.status(404).json({ error: "Rule not found" });
         return;
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const rawMap = await receiver.batchFetch(uids, folder || "INBOX");
-      const messages = [];
-      for (const [uid, raw] of rawMap) {
-        const parsed = await parseEmail(raw);
-        messages.push({ uid, ...parsed });
-      }
-      res.json({ messages, count: messages.length });
+      res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/mail/spam", requireAgent, async (req, res, next) => {
-    try {
-      const agent = req.agent;
-      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 200);
-      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      let mailboxInfo;
+  return router;
+}
+function evaluateRules(db, agentId, email) {
+  const rules = db.prepare("SELECT * FROM email_rules WHERE agent_id = ? AND enabled = 1 ORDER BY priority DESC").all(agentId);
+  for (const rule of rules) {
+    const cond = JSON.parse(rule.conditions);
+    let match = true;
+    const fromAddr = (email.from?.[0]?.address ?? "").toLowerCase();
+    const toAddr = (email.to?.[0]?.address ?? "").toLowerCase();
+    const subject = (email.subject ?? "").toLowerCase();
+    if (cond.from_contains && !fromAddr.includes(cond.from_contains.toLowerCase())) match = false;
+    if (cond.from_exact && fromAddr !== cond.from_exact.toLowerCase()) match = false;
+    if (cond.subject_contains && !subject.includes(cond.subject_contains.toLowerCase())) match = false;
+    if (cond.subject_regex) {
       try {
-        mailboxInfo = await receiver.getMailboxInfo("Spam");
+        if (!new RegExp(cond.subject_regex, "i").test(email.subject ?? "")) match = false;
       } catch {
-        res.json({ messages: [], count: 0, total: 0, folder: "Spam" });
-        return;
+        match = false;
       }
-      const envelopes = await receiver.listEnvelopes("Spam", { limit, offset });
-      res.json({ messages: envelopes, count: envelopes.length, total: mailboxInfo.exists, folder: "Spam" });
-    } catch (err) {
-      next(err);
     }
-  });
-  router.post("/mail/messages/:uid/spam", requireAgent, async (req, res, next) => {
+    if (cond.to_contains && !toAddr.includes(cond.to_contains.toLowerCase())) match = false;
+    if (cond.has_attachment === true && (!email.attachments || email.attachments.length === 0)) match = false;
+    if (match) return { ruleId: rule.id, actions: JSON.parse(rule.actions) };
+  }
+  return null;
+}
+function startScheduledSender(db, accountManager, config, gatewayManager) {
+  return setInterval(async () => {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
-        return;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const pending = db.prepare(
+        "SELECT * FROM scheduled_emails WHERE status = 'pending' AND send_at <= ?"
+      ).all(now);
+      for (const row of pending) {
+        try {
+          const agent = await accountManager.getById(row.agent_id);
+          if (!agent) {
+            db.prepare("UPDATE scheduled_emails SET status = 'failed', error = ? WHERE id = ?").run("Agent not found", row.id);
+            continue;
+          }
+          const mailOpts = {
+            to: row.to_addr,
+            subject: row.subject,
+            text: row.text_body || void 0,
+            html: row.html_body || void 0,
+            cc: row.cc || void 0,
+            bcc: row.bcc || void 0
+          };
+          if (gatewayManager) {
+            const gResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
+            if (gResult) {
+              db.prepare("UPDATE scheduled_emails SET status = 'sent', sent_at = datetime('now') WHERE id = ?").run(row.id);
+              continue;
+            }
+          }
+          const password = agent.metadata?._password || agent.name;
+          const sender = new MailSender({
+            host: config.smtp.host,
+            port: config.smtp.port,
+            email: agent.email,
+            password,
+            authUser: agent.stalwartPrincipal
+          });
+          try {
+            await sender.send(mailOpts);
+            db.prepare("UPDATE scheduled_emails SET status = 'sent', sent_at = datetime('now') WHERE id = ?").run(row.id);
+          } finally {
+            sender.close();
+          }
+        } catch (err) {
+          db.prepare("UPDATE scheduled_emails SET status = 'failed', error = ? WHERE id = ?").run(err.message, row.id);
+        }
       }
-      const folder = req.body?.folder || "INBOX";
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
       try {
-        await receiver.createFolder("Spam");
+        db.prepare("DELETE FROM delivered_messages WHERE delivered_at < datetime('now', '-30 days')").run();
       } catch {
       }
-      await receiver.moveMessage(uid, folder, "Spam");
-      res.json({ ok: true, movedToSpam: true });
-    } catch (err) {
-      next(err);
-    }
-  });
-  router.post("/mail/messages/:uid/not-spam", requireAgent, async (req, res, next) => {
-    try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
-        return;
+      try {
+        db.prepare("DELETE FROM spam_log WHERE created_at < datetime('now', '-30 days')").run();
+      } catch {
       }
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      await receiver.moveMessage(uid, "Spam", "INBOX");
-      res.json({ ok: true, movedToInbox: true });
-    } catch (err) {
-      next(err);
+    } catch {
     }
-  });
-  router.get("/mail/messages/:uid/spam-score", requireAgent, async (req, res, next) => {
+  }, 3e4);
+}
+
+// src/routes/events.ts
+var MAX_SSE_PER_AGENT = 5;
+var activeWatchers = /* @__PURE__ */ new Map();
+function pushEventToAgent(agentId, event) {
+  const watchers = activeWatchers.get(agentId);
+  if (!watchers || watchers.size === 0) return false;
+  const data = `data: ${JSON.stringify(event)}
+
+`;
+  for (const entry of watchers) {
     try {
-      const agent = req.agent;
-      const uid = parseInt(req.params.uid);
-      if (isNaN(uid) || uid < 1) {
-        res.status(400).json({ error: "Invalid UID" });
-        return;
+      entry.res.write(data);
+    } catch {
+    }
+  }
+  return true;
+}
+function broadcastEvent(event) {
+  const data = `data: ${JSON.stringify(event)}
+
+`;
+  let count = 0;
+  for (const [, watchers] of activeWatchers) {
+    for (const entry of watchers) {
+      try {
+        entry.res.write(data);
+        count++;
+      } catch {
       }
-      const folder = req.query.folder || "INBOX";
-      const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const raw = await receiver.fetchMessage(uid, folder);
-      const parsed = await parseEmail(raw);
-      if (isInternalEmail(parsed)) {
-        res.json({ score: 0, isSpam: false, isWarning: false, matches: [], topCategory: null, internal: true });
-        return;
+    }
+  }
+  return count;
+}
+async function closeAllWatchers() {
+  for (const [, watchers] of activeWatchers) {
+    for (const entry of watchers) {
+      try {
+        await entry.watcher.stop();
+      } catch {
+      }
+      try {
+        entry.res.end();
+      } catch {
       }
-      const result = scoreEmail(parsed);
-      res.json(result);
-    } catch (err) {
-      next(err);
     }
-  });
-  router.get("/mail/digest", requireAgent, async (req, res, next) => {
+  }
+  activeWatchers.clear();
+}
+function createEventRoutes(accountManager, config, db) {
+  const router = Router4();
+  router.get("/events", requireAgent, async (req, res, next) => {
     try {
       const agent = req.agent;
-      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 50);
-      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
-      const previewLen = Math.min(Math.max(parseInt(req.query.previewLength) || 200, 50), 500);
-      const folder = req.query.folder || "INBOX";
       const password = getAgentPassword(agent);
-      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
-      const mailboxInfo = await receiver.getMailboxInfo(folder);
-      const envelopes = await receiver.listEnvelopes(folder, { limit, offset });
-      const uids = envelopes.map((e) => e.uid);
-      const rawMap = uids.length > 0 ? await receiver.batchFetch(uids, folder) : /* @__PURE__ */ new Map();
-      const messages = [];
-      for (const env of envelopes) {
-        let preview = "";
-        const raw = rawMap.get(env.uid);
-        if (raw) {
-          const parsed = await parseEmail(raw);
-          preview = (parsed.text || "").slice(0, previewLen);
-        }
-        messages.push({
-          uid: env.uid,
-          subject: env.subject,
-          from: env.from,
-          to: env.to,
-          date: env.date,
-          flags: [...env.flags],
-          size: env.size,
-          preview
-        });
-      }
-      res.json({ messages, count: messages.length, total: mailboxInfo.exists });
-    } catch (err) {
-      next(err);
-    }
-  });
-  router.get("/mail/pending", requireAuth, async (req, res) => {
-    const rows = req.isMaster ? db.prepare(
-      `SELECT id, agent_id, mail_options, warnings, summary, status, created_at, resolved_at, resolved_by
-           FROM pending_outbound ORDER BY created_at DESC LIMIT 50`
-    ).all() : db.prepare(
-      `SELECT id, agent_id, mail_options, warnings, summary, status, created_at, resolved_at, resolved_by
-           FROM pending_outbound WHERE agent_id = ? ORDER BY created_at DESC LIMIT 50`
-    ).all(req.agent.id);
-    const pending = rows.map((r) => {
-      const opts = JSON.parse(r.mail_options);
-      return {
-        id: r.id,
-        agentId: r.agent_id,
-        to: opts.to,
-        subject: opts.subject,
-        warnings: JSON.parse(r.warnings),
-        summary: r.summary,
-        status: r.status,
-        createdAt: r.created_at,
-        resolvedAt: r.resolved_at,
-        resolvedBy: r.resolved_by
-      };
-    });
-    res.json({ pending, count: pending.length });
-  });
-  router.get("/mail/pending/:id", requireAuth, async (req, res) => {
-    const row = req.isMaster ? db.prepare(`SELECT * FROM pending_outbound WHERE id = ?`).get(req.params.id) : db.prepare(`SELECT * FROM pending_outbound WHERE id = ? AND agent_id = ?`).get(req.params.id, req.agent.id);
-    if (!row) {
-      res.status(404).json({ error: "Pending email not found" });
-      return;
-    }
-    res.json({
-      id: row.id,
-      mailOptions: JSON.parse(row.mail_options),
-      warnings: JSON.parse(row.warnings),
-      summary: row.summary,
-      status: row.status,
-      createdAt: row.created_at,
-      resolvedAt: row.resolved_at,
-      resolvedBy: row.resolved_by
-    });
-  });
-  router.post("/mail/pending/:id/approve", requireMaster, async (req, res, next) => {
-    try {
-      const row = db.prepare(
-        `SELECT * FROM pending_outbound WHERE id = ?`
-      ).get(req.params.id);
-      if (!row) {
-        res.status(404).json({ error: "Pending email not found" });
-        return;
-      }
-      if (row.status !== "pending") {
-        res.status(400).json({ error: `Email already ${row.status}` });
+      const agentWatchers = activeWatchers.get(agent.id) ?? /* @__PURE__ */ new Set();
+      if (agentWatchers.size >= MAX_SSE_PER_AGENT) {
+        res.status(429).json({ error: `Maximum ${MAX_SSE_PER_AGENT} concurrent SSE connections per agent` });
         return;
       }
-      const agent = await accountManager.getById(row.agent_id);
-      if (!agent) {
-        res.status(404).json({ error: "Agent account no longer exists" });
+      const watcher = new InboxWatcher({
+        host: config.imap.host,
+        port: config.imap.port,
+        email: agent.stalwartPrincipal,
+        password,
+        autoReconnect: true,
+        maxReconnectAttempts: 20
+      });
+      try {
+        await watcher.start();
+      } catch (err) {
+        res.status(500).json({ error: "Failed to start event stream: " + (err instanceof Error ? err.message : String(err)) });
         return;
       }
-      const mailOpts = JSON.parse(row.mail_options);
-      const ownerName = agent.metadata?.ownerName;
-      mailOpts.fromName = ownerName ? `${agent.name} from ${ownerName}` : agent.name;
-      if (Array.isArray(mailOpts.attachments)) {
-        for (const att of mailOpts.attachments) {
-          if (att.content && typeof att.content === "object" && att.content.type === "Buffer" && Array.isArray(att.content.data)) {
-            att.content = Buffer.from(att.content.data);
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache");
+      res.setHeader("Connection", "keep-alive");
+      res.setHeader("X-Accel-Buffering", "no");
+      res.flushHeaders();
+      let closed = false;
+      const entry = { watcher, res };
+      activeWatchers.set(agent.id, agentWatchers);
+      agentWatchers.add(entry);
+      const safeWrite = (data) => {
+        if (!closed) {
+          try {
+            res.write(data);
+          } catch {
           }
         }
-      }
-      const password = getAgentPassword(agent);
-      let response;
-      if (gatewayManager) {
-        const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
-        if (gatewayResult) {
-          if (gatewayResult.raw) {
-            saveSentCopy(agent.stalwartPrincipal, password, config, gatewayResult.raw);
+      };
+      safeWrite(`data: ${JSON.stringify({ type: "connected", agentId: agent.id })}
+
+`);
+      watcher.on("new", async (event) => {
+        if (db) touchActivity(db, agent.id);
+        if (db && event.uid) {
+          try {
+            const receiver = new MailReceiver({
+              host: config.imap.host,
+              port: config.imap.port,
+              email: agent.stalwartPrincipal,
+              password,
+              secure: false
+            });
+            await receiver.connect();
+            try {
+              const raw = await receiver.fetchMessage(event.uid);
+              const parsed = await parseEmail(raw);
+              const policyMetadata = agent.metadata && typeof agent.metadata === "object" ? {
+                emailRoutePolicy: agent.metadata.emailRoutePolicy,
+                routePolicy: agent.metadata.routePolicy,
+                mailboxPolicy: agent.metadata.mailboxPolicy
+              } : void 0;
+              const accountRouteContext = {
+                name: agent.name,
+                email: agent.email,
+                role: agent.role,
+                metadata: policyMetadata
+              };
+              const isRelay = !!parsed.headers.get("x-agenticmail-relay");
+              const internal = !isRelay && isInternalEmail(parsed);
+              if (internal) {
+                event.route = classifyEmailRoute({ email: parsed, account: accountRouteContext });
+                const ruleResult2 = evaluateRules(db, agent.id, parsed);
+                if (ruleResult2) {
+                  const actions = ruleResult2.actions;
+                  if (actions.mark_read) await receiver.markSeen(event.uid);
+                  if (actions.delete) {
+                    await receiver.deleteMessage(event.uid);
+                    return;
+                  }
+                  if (actions.move_to) await receiver.moveMessage(event.uid, "INBOX", actions.move_to);
+                  event.ruleApplied = { ruleId: ruleResult2.ruleId, actions };
+                }
+                safeWrite(`data: ${JSON.stringify(event)}
+
+`);
+                return;
+              }
+              const spamResult = scoreEmail(parsed);
+              event.route = classifyEmailRoute({ email: parsed, spam: spamResult, account: accountRouteContext });
+              try {
+                db.prepare(
+                  "INSERT INTO spam_log (id, agent_id, message_uid, score, flags, category, is_spam) VALUES (?, ?, ?, ?, ?, ?, ?)"
+                ).run(
+                  uuidv42(),
+                  agent.id,
+                  event.uid,
+                  spamResult.score,
+                  JSON.stringify(spamResult.matches.map((m) => m.ruleId)),
+                  spamResult.topCategory,
+                  spamResult.isSpam ? 1 : 0
+                );
+              } catch {
+              }
+              if (spamResult.isSpam) {
+                try {
+                  await receiver.createFolder("Spam");
+                } catch {
+                }
+                await receiver.moveMessage(event.uid, "INBOX", "Spam");
+                event.spam = { score: spamResult.score, category: spamResult.topCategory, movedToSpam: true };
+                safeWrite(`data: ${JSON.stringify(event)}
+
+`);
+                return;
+              }
+              if (spamResult.isWarning) {
+                event.spamWarning = { score: spamResult.score, category: spamResult.topCategory, matches: spamResult.matches.map((m) => m.ruleId) };
+              }
+              const ruleResult = evaluateRules(db, agent.id, parsed);
+              if (ruleResult) {
+                const actions = ruleResult.actions;
+                if (actions.mark_read) await receiver.markSeen(event.uid);
+                if (actions.delete) {
+                  await receiver.deleteMessage(event.uid);
+                  return;
+                }
+                if (actions.move_to) await receiver.moveMessage(event.uid, "INBOX", actions.move_to);
+                event.ruleApplied = { ruleId: ruleResult.ruleId, actions };
+              }
+            } finally {
+              await receiver.disconnect();
+            }
+          } catch (err) {
+            console.error("[SSE] Spam/rule evaluation error:", err.message);
           }
-          const { raw: _raw, ...rest } = gatewayResult;
-          response = rest;
         }
-      }
-      if (!response) {
-        const sender = getSender(agent.stalwartPrincipal, agent.email, password, config);
-        const result = await sender.send(mailOpts);
-        saveSentCopy(agent.stalwartPrincipal, password, config, result.raw);
-        const { raw: _raw, ...rest } = result;
-        response = rest;
-      }
-      db.prepare(
-        `UPDATE pending_outbound SET status = 'approved', resolved_at = datetime('now'), resolved_by = ? WHERE id = ?`
-      ).run("master", row.id);
-      res.json({ ...response, approved: true, pendingId: row.id });
-    } catch (err) {
-      next(err);
-    }
-  });
-  router.post("/mail/pending/:id/reject", requireMaster, async (req, res) => {
-    const row = db.prepare(
-      `SELECT * FROM pending_outbound WHERE id = ?`
-    ).get(req.params.id);
-    if (!row) {
-      res.status(404).json({ error: "Pending email not found" });
-      return;
-    }
-    if (row.status !== "pending") {
-      res.status(400).json({ error: `Email already ${row.status}` });
-      return;
-    }
-    db.prepare(
-      `UPDATE pending_outbound SET status = 'rejected', resolved_at = datetime('now'), resolved_by = ? WHERE id = ?`
-    ).run("master", row.id);
-    res.json({ ok: true, rejected: true, pendingId: row.id });
-  });
-  return router;
-}
+        safeWrite(`data: ${JSON.stringify(event)}
 
-// src/routes/inbound.ts
-import { Router as Router4 } from "express";
-import { randomUUID } from "crypto";
-import {
-  parseEmail as parseEmail2,
-  MailSender as MailSender2
-} from "@agenticmail/core";
-var INBOUND_SECRET = process.env.AGENTICMAIL_INBOUND_SECRET || (() => {
-  const generated = randomUUID();
-  console.warn("[Inbound] WARNING: AGENTICMAIL_INBOUND_SECRET is not set. Generated a random secret for this session.");
-  console.warn(`[Inbound] Set AGENTICMAIL_INBOUND_SECRET="${generated}" in your environment to persist it across restarts.`);
-  return generated;
-})();
-var DEBUG = () => !!process.env.AGENTICMAIL_DEBUG;
-function createInboundRoutes(accountManager, config, gatewayManager) {
-  const router = Router4();
-  router.post("/mail/inbound", async (req, res, next) => {
-    try {
-      const secret = req.headers["x-inbound-secret"];
-      if (secret !== INBOUND_SECRET) {
-        res.status(401).json({ error: "Invalid inbound secret" });
-        return;
-      }
-      const { from, to, subject, rawEmail } = req.body;
-      if (!to || !rawEmail) {
-        res.status(400).json({ error: "to and rawEmail are required" });
-        return;
-      }
-      const recipientEmail = typeof to === "string" ? to : to[0];
-      const localPart = recipientEmail.split("@")[0];
-      const agent = await accountManager.getByName(localPart);
-      if (!agent) {
-        console.warn(`[Inbound] No agent found for "${localPart}" (${recipientEmail})`);
-        res.status(404).json({ error: `No agent found for ${recipientEmail}` });
-        return;
-      }
-      const agentPassword = agent.metadata?._password;
-      if (!agentPassword) {
-        console.warn(`[Inbound] No password for agent "${agent.name}"`);
-        res.status(500).json({ error: "Agent has no password configured" });
-        return;
-      }
-      const rawBuffer = Buffer.from(rawEmail, "base64");
-      const parsed = await parseEmail2(rawBuffer);
-      const originalMessageId = parsed.messageId;
-      if (originalMessageId && gatewayManager?.isAlreadyDelivered(originalMessageId, agent.name)) {
-        if (DEBUG()) console.log(`[Inbound] Skipping duplicate: ${originalMessageId} \u2192 ${agent.name}`);
-        res.json({ ok: true, delivered: agent.email, duplicate: true });
-        return;
-      }
-      if (DEBUG()) console.log(`[Inbound] Delivering email to ${agent.email} from ${from} (subject: ${subject || parsed.subject})`);
-      const sender = new MailSender2({
-        host: config.smtp.host,
-        port: config.smtp.port,
-        email: agent.email,
-        password: agentPassword,
-        authUser: agent.stalwartPrincipal
+`);
+      });
+      watcher.on("expunge", (event) => {
+        safeWrite(`data: ${JSON.stringify(event)}
+
+`);
+      });
+      watcher.on("flags", (event) => {
+        safeWrite(`data: ${JSON.stringify(event)}
+
+`);
+      });
+      watcher.on("error", (err) => {
+        safeWrite(`data: ${JSON.stringify({ type: "error", message: err.message })}
+
+`);
+      });
+      watcher.on("reconnecting", (info) => {
+        safeWrite(`data: ${JSON.stringify({ type: "reconnecting", attempt: info.attempt, delayMs: info.delayMs })}
+
+`);
       });
-      try {
-        await sender.send({
-          to: agent.email,
-          subject: parsed.subject || subject || "(no subject)",
-          text: parsed.text || void 0,
-          html: parsed.html || void 0,
-          replyTo: from || parsed.from?.[0]?.address,
-          inReplyTo: parsed.inReplyTo,
-          references: parsed.references,
-          headers: {
-            "X-AgenticMail-Inbound": "cloudflare-worker",
-            "X-Original-From": from || parsed.from?.[0]?.address || "",
-            ...parsed.messageId ? { "X-Original-Message-Id": parsed.messageId } : {}
-          },
-          attachments: parsed.attachments?.map((a) => ({
-            filename: a.filename,
-            content: a.content,
-            contentType: a.contentType
-          }))
+      watcher.on("reconnected", (info) => {
+        safeWrite(`data: ${JSON.stringify({ type: "reconnected", attempt: info.attempt })}
+
+`);
+      });
+      watcher.on("reconnect_failed", (info) => {
+        safeWrite(`data: ${JSON.stringify({ type: "reconnect_failed", attempts: info.attempts })}
+
+`);
+      });
+      const pingInterval = setInterval(() => {
+        safeWrite(`: ping
+
+`);
+      }, 3e4);
+      req.on("close", () => {
+        closed = true;
+        clearInterval(pingInterval);
+        agentWatchers.delete(entry);
+        if (agentWatchers.size === 0) activeWatchers.delete(agent.id);
+        watcher.removeAllListeners();
+        watcher.stop().catch((err) => {
+          console.error("[SSE] Watcher cleanup error:", err);
         });
-        if (originalMessageId) gatewayManager?.recordDelivery(originalMessageId, agent.name);
-        if (DEBUG()) console.log(`[Inbound] Delivered to ${agent.email}`);
-        res.json({ ok: true, delivered: agent.email });
-      } finally {
-        sender.close();
-      }
+      });
     } catch (err) {
       next(err);
     }
@@ -1485,904 +1405,1056 @@ function createInboundRoutes(accountManager, config, gatewayManager) {
   return router;
 }
 
-// src/routes/events.ts
-import { Router as Router6 } from "express";
-import {
-  InboxWatcher,
-  MailReceiver as MailReceiver2,
-  parseEmail as parseEmail3,
-  scoreEmail as scoreEmail2,
-  isInternalEmail as isInternalEmail2,
-  classifyEmailRoute
-} from "@agenticmail/core";
-import { v4 as uuidv42 } from "uuid";
-
-// src/routes/features.ts
-import { Router as Router5 } from "express";
-import { v4 as uuidv4 } from "uuid";
-import {
-  MailSender as MailSender3
-} from "@agenticmail/core";
-function parseScheduleTime(input) {
-  const trimmed = input.trim();
-  if (/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(trimmed)) {
-    const d = new Date(trimmed);
-    return isNaN(d.getTime()) ? null : d;
+// src/routes/mail.ts
+var senderCache = /* @__PURE__ */ new Map();
+var receiverCache = /* @__PURE__ */ new Map();
+var receiverPending = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 10 * 60 * 1e3;
+var MAX_CACHE_SIZE = 100;
+var draining = false;
+function getAgentPassword(agent) {
+  return agent.metadata?._password || agent.name;
+}
+var evictionTimer = null;
+function startEvictionTimer() {
+  if (evictionTimer) return;
+  evictionTimer = setInterval(evictStaleEntries, 6e4);
+}
+function evictStaleEntries() {
+  const now = Date.now();
+  for (const [key, entry] of senderCache) {
+    if (now - entry.createdAt > CACHE_TTL_MS) {
+      try {
+        entry.sender.close();
+      } catch {
+      }
+      senderCache.delete(key);
+    }
   }
-  const lower = trimmed.toLowerCase();
-  const relativeMatch = lower.match(/^in\s+(\d+)\s+(minute|minutes|min|mins|hour|hours|hr|hrs|day|days)$/);
-  if (relativeMatch) {
-    const amount = parseInt(relativeMatch[1], 10);
-    const unit = relativeMatch[2];
-    const now = Date.now();
-    if (unit.startsWith("min")) return new Date(now + amount * 6e4);
-    if (unit.startsWith("h")) return new Date(now + amount * 36e5);
-    if (unit.startsWith("d")) return new Date(now + amount * 864e5);
+  for (const [key, entry] of receiverCache) {
+    if (now - entry.createdAt > CACHE_TTL_MS) {
+      entry.receiver.disconnect().catch(() => {
+      });
+      receiverCache.delete(key);
+    }
   }
-  const tomorrowMatch = lower.match(/^tomorrow\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
-  if (tomorrowMatch) {
-    const tomorrow = /* @__PURE__ */ new Date();
-    tomorrow.setDate(tomorrow.getDate() + 1);
-    let hour = parseInt(tomorrowMatch[1], 10);
-    const min = tomorrowMatch[2] ? parseInt(tomorrowMatch[2], 10) : 0;
-    const ampm = tomorrowMatch[3];
-    if (ampm === "pm" && hour !== 12) hour += 12;
-    if (ampm === "am" && hour === 12) hour = 0;
-    tomorrow.setHours(hour, min, 0, 0);
-    return tomorrow;
+}
+function getSender(authUser, fromEmail, password, config) {
+  if (draining) throw new Error("Server is shutting down");
+  const cacheKey = `${authUser}:${fromEmail}`;
+  const cached = senderCache.get(cacheKey);
+  if (cached) return cached.sender;
+  if (senderCache.size >= MAX_CACHE_SIZE) {
+    const oldest = senderCache.keys().next().value;
+    if (oldest) {
+      try {
+        senderCache.get(oldest)?.sender.close();
+      } catch {
+      }
+      senderCache.delete(oldest);
+    }
   }
-  const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
-  const nextDayMatch = lower.match(/^next\s+(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
-  if (nextDayMatch) {
-    const targetDay = dayNames.indexOf(nextDayMatch[1]);
-    let hour = parseInt(nextDayMatch[2], 10);
-    const min = nextDayMatch[3] ? parseInt(nextDayMatch[3], 10) : 0;
-    const ampm = nextDayMatch[4];
-    if (ampm === "pm" && hour !== 12) hour += 12;
-    if (ampm === "am" && hour === 12) hour = 0;
-    const result = /* @__PURE__ */ new Date();
-    const currentDay = result.getDay();
-    let daysUntil = targetDay - currentDay;
-    if (daysUntil <= 0) daysUntil += 7;
-    result.setDate(result.getDate() + daysUntil);
-    result.setHours(hour, min, 0, 0);
-    return result;
+  const sender = new MailSender2({
+    host: config.smtp.host,
+    port: config.smtp.port,
+    email: fromEmail,
+    password,
+    authUser
+  });
+  senderCache.set(cacheKey, { sender, createdAt: Date.now() });
+  startEvictionTimer();
+  return sender;
+}
+async function getReceiver(authUser, password, config) {
+  if (draining) throw new Error("Server is shutting down");
+  const cached = receiverCache.get(authUser);
+  if (cached) {
+    try {
+      const client = cached.receiver.getImapClient();
+      if (client.usable) return cached.receiver;
+    } catch {
+    }
+    try {
+      await cached.receiver.disconnect();
+    } catch {
+    }
+    receiverCache.delete(authUser);
   }
-  if (lower === "tonight" || lower === "this evening") {
-    const d = /* @__PURE__ */ new Date();
-    d.setHours(20, 0, 0, 0);
-    if (d.getTime() <= Date.now()) d.setDate(d.getDate() + 1);
-    return d;
+  const pending = receiverPending.get(authUser);
+  if (pending) return pending;
+  const promise = createReceiver(authUser, password, config);
+  receiverPending.set(authUser, promise);
+  try {
+    return await promise;
+  } finally {
+    receiverPending.delete(authUser);
   }
-  const humanMatch = trimmed.match(
-    /^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})\s+(\d{1,2}):(\d{2})\s*(AM|PM|am|pm)\s*(.+)?$/
-  );
-  if (humanMatch) {
-    const [, mStr, dStr, yStr, hStr, minStr, ampmRaw, tzRaw] = humanMatch;
-    const month = parseInt(mStr, 10);
-    const day = parseInt(dStr, 10);
-    const year = parseInt(yStr, 10);
-    let hour = parseInt(hStr, 10);
-    const min = parseInt(minStr, 10);
-    const ampm = ampmRaw.toUpperCase();
-    if (month < 1 || month > 12 || day < 1 || day > 31 || hour < 1 || hour > 12) return null;
-    if (ampm === "PM" && hour !== 12) hour += 12;
-    if (ampm === "AM" && hour === 12) hour = 0;
-    const result = new Date(year, month - 1, day, hour, min, 0, 0);
-    if (tzRaw?.trim()) {
-      const TZ_OFFSETS = {
-        EST: -5,
-        EDT: -4,
-        CST: -6,
-        CDT: -5,
-        MST: -7,
-        MDT: -6,
-        PST: -8,
-        PDT: -7,
-        GMT: 0,
-        UTC: 0,
-        BST: 1,
-        CET: 1,
-        CEST: 2,
-        IST: 5.5,
-        JST: 9,
-        AEST: 10,
-        AEDT: 11,
-        NZST: 12,
-        NZDT: 13,
-        WAT: 1,
-        EAT: 3,
-        SAST: 2,
-        HKT: 8,
-        SGT: 8,
-        KST: 9,
-        HST: -10,
-        AKST: -9,
-        AKDT: -8,
-        AST: -4,
-        ADT: -3,
-        NST: -3.5,
-        NDT: -2.5
-      };
-      const tz = tzRaw.trim().toUpperCase();
-      if (TZ_OFFSETS[tz] !== void 0) {
-        const tzOffsetMs = TZ_OFFSETS[tz] * 36e5;
-        const serverOffsetMs = result.getTimezoneOffset() * -6e4;
-        const diff = serverOffsetMs - tzOffsetMs;
-        result.setTime(result.getTime() + diff);
-      }
+}
+async function createReceiver(authUser, password, config) {
+  if (receiverCache.size >= MAX_CACHE_SIZE) {
+    const oldest = receiverCache.keys().next().value;
+    if (oldest) {
+      receiverCache.get(oldest)?.receiver.disconnect().catch(() => {
+      });
+      receiverCache.delete(oldest);
     }
-    return isNaN(result.getTime()) ? null : result;
   }
-  const fallback = new Date(trimmed);
-  return isNaN(fallback.getTime()) ? null : fallback;
-}
-function createFeatureRoutes(db, _accountManager, config, gatewayManager) {
-  const router = Router5();
-  router.get("/contacts", requireAgent, async (req, res, next) => {
+  const receiver = new MailReceiver2({
+    host: config.imap.host,
+    port: config.imap.port,
+    email: authUser,
+    password
+  });
+  try {
+    await receiver.connect();
+  } catch (err) {
     try {
-      const rows = db.prepare("SELECT * FROM contacts WHERE agent_id = ? ORDER BY name, email").all(req.agent.id);
-      res.json({ contacts: rows });
-    } catch (err) {
-      next(err);
+      await receiver.disconnect();
+    } catch {
     }
-  });
-  router.post("/contacts", requireAgent, async (req, res, next) => {
+    throw err;
+  }
+  receiverCache.set(authUser, { receiver, createdAt: Date.now() });
+  startEvictionTimer();
+  return receiver;
+}
+async function closeCaches() {
+  draining = true;
+  if (evictionTimer) {
+    clearInterval(evictionTimer);
+    evictionTimer = null;
+  }
+  for (const [, entry] of senderCache) {
     try {
-      const { name: name2, email, notes } = req.body || {};
-      if (!email) {
-        res.status(400).json({ error: "email is required" });
-        return;
-      }
-      const id = uuidv4();
-      db.prepare("INSERT OR REPLACE INTO contacts (id, agent_id, name, email, notes) VALUES (?, ?, ?, ?, ?)").run(id, req.agent.id, name2 || null, email, notes || null);
-      res.json({ ok: true, id, email });
-    } catch (err) {
-      next(err);
+      entry.sender.close();
+    } catch {
     }
-  });
-  router.delete("/contacts/:id", requireAgent, async (req, res, next) => {
+  }
+  senderCache.clear();
+  for (const [, entry] of receiverCache) {
     try {
-      const result = db.prepare("DELETE FROM contacts WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Contact not found" });
-        return;
-      }
-      res.json({ ok: true });
-    } catch (err) {
-      next(err);
+      await entry.receiver.disconnect();
+    } catch {
     }
-  });
-  router.get("/drafts", requireAgent, async (req, res, next) => {
+  }
+  receiverCache.clear();
+}
+async function notifyLocalRecipientsOfNewMail(accountManager, toField, ccField, bccField, fromAgent, subject, messageId) {
+  const collected = [];
+  const push = (v) => {
+    if (!v) return;
+    if (Array.isArray(v)) collected.push(...v);
+    else collected.push(v);
+  };
+  push(toField);
+  push(ccField);
+  push(bccField);
+  const addrRe = /<([^>]+)>|([^\s,;<>]+@[^\s,;<>]+)/g;
+  const addresses = /* @__PURE__ */ new Set();
+  for (const entry of collected) {
+    let match;
+    addrRe.lastIndex = 0;
+    while ((match = addrRe.exec(entry)) !== null) {
+      const a = (match[1] || match[2] || "").trim().toLowerCase();
+      if (a) addresses.add(a);
+    }
+  }
+  const notified = /* @__PURE__ */ new Set();
+  for (const addr of addresses) {
+    const at = addr.indexOf("@");
+    if (at < 0) continue;
+    const localPart = addr.slice(0, at);
+    const domain = addr.slice(at + 1);
+    if (domain !== "localhost") continue;
+    if (addr === fromAgent.email.toLowerCase()) continue;
+    let recipient = null;
+    try {
+      recipient = await accountManager.getByName(localPart);
+    } catch {
+    }
+    if (!recipient || notified.has(recipient.id)) continue;
+    notified.add(recipient.id);
+    pushEventToAgent(recipient.id, {
+      type: "new",
+      // uid is unknown without an IMAP fetch; use 0 as a sentinel —
+      // this matches the watcher's autoFetch=false path. SSE consumers
+      // that want full message detail can call /mail/inbox.
+      uid: 0,
+      internal: true,
+      from: { name: fromAgent.name, address: fromAgent.email },
+      subject,
+      messageId
+    });
+  }
+}
+function saveSentCopy(authUser, password, config, raw) {
+  (async () => {
     try {
-      const rows = db.prepare("SELECT * FROM drafts WHERE agent_id = ? ORDER BY updated_at DESC").all(req.agent.id);
-      res.json({ drafts: rows });
+      const receiver = await getReceiver(authUser, password, config);
+      await receiver.appendMessage(raw, "Sent Items", ["\\Seen"]);
     } catch (err) {
-      next(err);
+      console.warn(`[mail] Failed to save Sent copy for ${authUser}: ${err.message}`);
     }
-  });
-  router.post("/drafts", requireAgent, async (req, res, next) => {
+  })();
+}
+function createMailRoutes(accountManager, config, db, gatewayManager) {
+  const router = Router5();
+  router.post("/mail/send", requireAgent, async (req, res, next) => {
     try {
-      const { to, subject, text, html, cc, bcc, inReplyTo, references } = req.body || {};
-      const id = uuidv4();
-      db.prepare(`INSERT INTO drafts (id, agent_id, to_addr, subject, text_body, html_body, cc, bcc, in_reply_to, refs)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
-        id,
-        req.agent.id,
-        to || null,
-        subject || null,
-        text || null,
-        html || null,
-        cc || null,
-        bcc || null,
-        inReplyTo || null,
-        references ? JSON.stringify(references) : null
-      );
-      res.json({ ok: true, id });
+      if (!req.body || typeof req.body !== "object") {
+        res.status(400).json({ error: "Request body must be JSON" });
+        return;
+      }
+      const agent = req.agent;
+      const { to, subject, text, html, cc, bcc, replyTo, inReplyTo, references, attachments, allowSensitive } = req.body;
+      if (!to || !subject) {
+        res.status(400).json({ error: "to and subject are required" });
+        return;
+      }
+      if (typeof to !== "string" && !Array.isArray(to)) {
+        res.status(400).json({ error: "to must be a string or array of strings" });
+        return;
+      }
+      let outboundWarnings;
+      let outboundSummary;
+      if (!(allowSensitive && req.isMaster)) {
+        const scanResult = scanOutboundEmail({
+          to: Array.isArray(to) ? to.join(", ") : to,
+          subject,
+          text,
+          html,
+          attachments: Array.isArray(attachments) ? attachments.map((a) => ({
+            filename: a.filename || "",
+            contentType: a.contentType,
+            content: a.content,
+            encoding: a.encoding
+          })) : void 0
+        });
+        if (scanResult.blocked) {
+          const pendingId = crypto.randomUUID();
+          const ownerName2 = agent.metadata?.ownerName;
+          const fromName2 = ownerName2 ? `${agent.name} from ${ownerName2}` : agent.name;
+          const mailOptions = { to, subject, text, html, cc, bcc, replyTo, inReplyTo, references, attachments, fromName: fromName2 };
+          db.prepare(
+            `INSERT INTO pending_outbound (id, agent_id, mail_options, warnings, summary) VALUES (?, ?, ?, ?, ?)`
+          ).run(pendingId, agent.id, JSON.stringify(mailOptions), JSON.stringify(scanResult.warnings), scanResult.summary);
+          if (gatewayManager) {
+            const ownerEmail = gatewayManager.getConfig()?.relay?.email;
+            if (ownerEmail) {
+              const warningList = scanResult.warnings.map((w) => `  - [${w.severity.toUpperCase()}] ${w.ruleId}: ${w.description}${w.match ? ` (matched: ${w.match})` : ""}`).join("\n");
+              const recipientLine = Array.isArray(to) ? to.join(", ") : to;
+              const emailPreview = [
+                "\u2500".repeat(50),
+                `From: ${fromName2} <${agent.email}>`,
+                `To: ${recipientLine}`
+              ];
+              if (cc) emailPreview.push(`CC: ${Array.isArray(cc) ? cc.join(", ") : cc}`);
+              if (bcc) emailPreview.push(`BCC: ${Array.isArray(bcc) ? bcc.join(", ") : bcc}`);
+              emailPreview.push(`Subject: ${subject}`);
+              if (Array.isArray(attachments) && attachments.length > 0) {
+                const attNames = attachments.map((a) => a.filename || "unnamed").join(", ");
+                emailPreview.push(`Attachments: ${attNames}`);
+              }
+              emailPreview.push("\u2500".repeat(50));
+              if (text) emailPreview.push("", text);
+              else if (html) emailPreview.push("", "[HTML content \u2014 see original for formatted version]");
+              else emailPreview.push("", "[No body content]");
+              emailPreview.push("\u2500".repeat(50));
+              gatewayManager.routeOutbound(agent.name, {
+                to: ownerEmail,
+                subject: `[Approval Required] Blocked email from "${agent.name}" \u2014 "${subject}"`,
+                text: [
+                  `Your agent "${agent.name}" attempted to send an email that was blocked by the outbound security guard.`,
+                  "",
+                  "SECURITY WARNINGS:",
+                  warningList,
+                  "",
+                  "FULL EMAIL FOR REVIEW:",
+                  ...emailPreview,
+                  "",
+                  `Pending ID: ${pendingId}`,
+                  "",
+                  "ACTION REQUIRED:",
+                  'Reply "approve" to this email to send it, or "reject" to discard it.',
+                  "If you do not respond, the agent will follow up with you."
+                ].join("\n"),
+                fromName: "Agentic Mail"
+              }).then((result2) => {
+                if (result2?.messageId) {
+                  db.prepare("UPDATE pending_outbound SET notification_message_id = ? WHERE id = ?").run(result2.messageId, pendingId);
+                }
+              }).catch(() => {
+              });
+            }
+          }
+          res.json({
+            sent: false,
+            blocked: true,
+            pendingId,
+            warnings: scanResult.warnings,
+            summary: scanResult.summary
+          });
+          return;
+        }
+        if (scanResult.warnings.length > 0) {
+          outboundWarnings = scanResult.warnings;
+          outboundSummary = scanResult.summary;
+        }
+      }
+      const ownerName = agent.metadata?.ownerName;
+      const fromName = ownerName ? `${agent.name} from ${ownerName}` : agent.name;
+      const mailOpts = { to, subject, text, html, cc, bcc, replyTo, inReplyTo, references, attachments, fromName };
+      const password = getAgentPassword(agent);
+      if (gatewayManager) {
+        const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
+        if (gatewayResult) {
+          if (gatewayResult.raw) {
+            saveSentCopy(agent.stalwartPrincipal, password, config, gatewayResult.raw);
+          }
+          const { raw: _raw2, ...response2 } = gatewayResult;
+          res.json({ ...response2, ...outboundWarnings ? { outboundWarnings, outboundSummary } : {} });
+          return;
+        }
+      }
+      const sender = getSender(agent.stalwartPrincipal, agent.email, password, config);
+      const result = await sender.send(mailOpts);
+      saveSentCopy(agent.stalwartPrincipal, password, config, result.raw);
+      notifyLocalRecipientsOfNewMail(
+        accountManager,
+        to,
+        cc,
+        bcc,
+        agent,
+        subject,
+        result.messageId
+      ).catch((err) => {
+        console.warn(`[mail] Internal SSE notify failed: ${err.message}`);
+      });
+      const { raw: _raw, ...response } = result;
+      res.json({ ...response, ...outboundWarnings ? { outboundWarnings, outboundSummary } : {} });
     } catch (err) {
       next(err);
     }
   });
-  router.put("/drafts/:id", requireAgent, async (req, res, next) => {
+  router.get("/mail/inbox", requireAgent, async (req, res, next) => {
     try {
-      const { to, subject, text, html, cc, bcc, inReplyTo, references } = req.body || {};
-      const result = db.prepare(`UPDATE drafts SET to_addr=?, subject=?, text_body=?, html_body=?,
-        cc=?, bcc=?, in_reply_to=?, refs=?, updated_at=datetime('now')
-        WHERE id=? AND agent_id=?`).run(
-        to || null,
-        subject || null,
-        text || null,
-        html || null,
-        cc || null,
-        bcc || null,
-        inReplyTo || null,
-        references ? JSON.stringify(references) : null,
-        req.params.id,
-        req.agent.id
-      );
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Draft not found" });
-        return;
-      }
-      res.json({ ok: true });
+      const agent = req.agent;
+      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 200);
+      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const mailboxInfo = await receiver.getMailboxInfo("INBOX");
+      const envelopes = await receiver.listEnvelopes("INBOX", { limit, offset });
+      res.json({ messages: envelopes, count: envelopes.length, total: mailboxInfo.exists });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/drafts/:id", requireAgent, async (req, res, next) => {
+  router.get("/mail/messages/:uid", requireAgent, async (req, res, next) => {
     try {
-      const result = db.prepare("DELETE FROM drafts WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Draft not found" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
         return;
       }
-      res.json({ ok: true });
+      const folder = req.query.folder || "INBOX";
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const raw = await receiver.fetchMessage(uid, folder);
+      const parsed = await parseEmail2(raw);
+      if (isInternalEmail2(parsed)) {
+        res.json({
+          ...parsed,
+          security: { internal: true, spamScore: 0, isSpam: false, isWarning: false }
+        });
+        return;
+      }
+      const sanitized = sanitizeEmail(parsed);
+      const spamScore = scoreEmail2(parsed);
+      res.json({
+        ...parsed,
+        text: sanitized.text,
+        html: sanitized.html,
+        security: {
+          spamScore: spamScore.score,
+          isSpam: spamScore.isSpam,
+          isWarning: spamScore.isWarning,
+          topCategory: spamScore.topCategory,
+          matches: spamScore.matches.map((m) => m.ruleId),
+          sanitized: sanitized.wasModified,
+          sanitizeDetections: sanitized.detections
+        }
+      });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/drafts/:id/send", requireAgent, async (req, res, next) => {
+  router.get("/mail/messages/:uid/attachments/:index", requireAgent, async (req, res, next) => {
     try {
-      const draft = db.prepare("SELECT * FROM drafts WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
-      if (!draft) {
-        res.status(404).json({ error: "Draft not found" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      const index = parseInt(req.params.index);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
         return;
       }
-      if (!draft.to_addr) {
-        res.status(400).json({ error: "Draft has no recipient" });
+      if (isNaN(index) || index < 0) {
+        res.status(400).json({ error: "Invalid attachment index" });
         return;
       }
-      const agent = req.agent;
-      const mailOpts = {
-        to: draft.to_addr,
-        subject: draft.subject || "(no subject)",
-        text: draft.text_body || void 0,
-        html: draft.html_body || void 0,
-        cc: draft.cc || void 0,
-        bcc: draft.bcc || void 0,
-        inReplyTo: draft.in_reply_to || void 0,
-        references: draft.refs ? JSON.parse(draft.refs) : void 0
-      };
-      if (gatewayManager) {
-        const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
-        if (gatewayResult) {
-          db.prepare("DELETE FROM drafts WHERE id = ?").run(draft.id);
-          res.json(gatewayResult);
-          return;
-        }
-      }
+      const folder = req.query.folder || "INBOX";
       const password = getAgentPassword(agent);
-      const sender = new MailSender3({
-        host: config.smtp.host,
-        port: config.smtp.port,
-        email: agent.email,
-        password,
-        authUser: agent.stalwartPrincipal
-      });
-      try {
-        const result = await sender.send(mailOpts);
-        db.prepare("DELETE FROM drafts WHERE id = ?").run(draft.id);
-        res.json(result);
-      } finally {
-        sender.close();
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const raw = await receiver.fetchMessage(uid, folder);
+      const parsed = await parseEmail2(raw);
+      if (!parsed.attachments || index >= parsed.attachments.length) {
+        res.status(404).json({ error: "Attachment not found" });
+        return;
       }
+      const att = parsed.attachments[index];
+      res.setHeader("Content-Type", att.contentType || "application/octet-stream");
+      res.setHeader("Content-Disposition", `attachment; filename="${att.filename.replace(/"/g, '\\"')}"`);
+      res.setHeader("Content-Length", att.content.length);
+      res.send(att.content);
     } catch (err) {
       next(err);
     }
   });
-  router.get("/signatures", requireAgent, async (req, res, next) => {
+  router.post("/mail/search", requireAgent, async (req, res, next) => {
     try {
-      const rows = db.prepare("SELECT * FROM signatures WHERE agent_id = ? ORDER BY is_default DESC, name").all(req.agent.id);
-      res.json({ signatures: rows });
+      if (!req.body || typeof req.body !== "object") {
+        res.status(400).json({ error: "Request body must be JSON" });
+        return;
+      }
+      const agent = req.agent;
+      const { from, to, subject, since, before, seen, text, searchRelay } = req.body;
+      const password = getAgentPassword(agent);
+      const sinceDate = since ? new Date(since) : void 0;
+      const beforeDate = before ? new Date(before) : void 0;
+      if (sinceDate && isNaN(sinceDate.getTime())) {
+        res.status(400).json({ error: 'Invalid "since" date' });
+        return;
+      }
+      if (beforeDate && isNaN(beforeDate.getTime())) {
+        res.status(400).json({ error: 'Invalid "before" date' });
+        return;
+      }
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const uids = await receiver.search({
+        from,
+        to,
+        subject,
+        since: sinceDate,
+        before: beforeDate,
+        seen,
+        text
+      });
+      let relayResults;
+      if (searchRelay === true && gatewayManager) {
+        try {
+          const relayHits = await gatewayManager.searchRelay({
+            from,
+            to,
+            subject,
+            text,
+            since: sinceDate,
+            before: beforeDate,
+            seen
+          });
+          if (relayHits.length > 0) {
+            relayResults = relayHits.map((r) => ({
+              uid: r.uid,
+              source: r.source,
+              account: r.account,
+              messageId: r.messageId,
+              subject: r.subject,
+              from: r.from,
+              to: r.to,
+              date: r.date,
+              flags: r.flags
+            }));
+          }
+        } catch {
+        }
+      }
+      res.json({ uids, ...relayResults ? { relayResults } : {} });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/signatures", requireAgent, async (req, res, next) => {
+  router.post("/mail/import-relay", requireAgent, async (req, res, next) => {
     try {
-      const { name: name2, text, html, isDefault } = req.body || {};
-      if (!name2) {
-        res.status(400).json({ error: "name is required" });
+      const { uid } = req.body || {};
+      if (!uid || typeof uid !== "number" || uid < 1) {
+        res.status(400).json({ error: "uid (number) is required" });
         return;
       }
-      const id = uuidv4();
-      if (isDefault) {
-        db.prepare("UPDATE signatures SET is_default = 0 WHERE agent_id = ?").run(req.agent.id);
+      if (!gatewayManager) {
+        res.status(400).json({ error: "No gateway configured" });
+        return;
       }
-      db.prepare("INSERT OR REPLACE INTO signatures (id, agent_id, name, text_content, html_content, is_default) VALUES (?, ?, ?, ?, ?, ?)").run(id, req.agent.id, name2, text || null, html || null, isDefault ? 1 : 0);
-      res.json({ ok: true, id });
+      const agent = req.agent;
+      const result = await gatewayManager.importRelayMessage(uid, agent.name);
+      if (!result.success) {
+        res.status(400).json({ error: result.error || "Import failed" });
+        return;
+      }
+      res.json({ ok: true, message: "Email imported to local inbox. Use /inbox or list_inbox to see it." });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/signatures/:id", requireAgent, async (req, res, next) => {
+  router.post("/mail/messages/:uid/seen", requireAgent, async (req, res, next) => {
     try {
-      const result = db.prepare("DELETE FROM signatures WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Signature not found" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
         return;
       }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.markSeen(uid);
       res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/templates", requireAgent, async (req, res, next) => {
+  router.delete("/mail/messages/:uid", requireAgent, async (req, res, next) => {
     try {
-      const rows = db.prepare("SELECT * FROM templates WHERE agent_id = ? ORDER BY name").all(req.agent.id);
-      res.json({ templates: rows });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
+        return;
+      }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.deleteMessage(uid);
+      res.status(204).send();
     } catch (err) {
       next(err);
     }
   });
-  router.post("/templates", requireAgent, async (req, res, next) => {
+  router.post("/mail/messages/:uid/unseen", requireAgent, async (req, res, next) => {
     try {
-      const { name: name2, subject, text, html } = req.body || {};
-      if (!name2) {
-        res.status(400).json({ error: "name is required" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
         return;
       }
-      const id = uuidv4();
-      db.prepare("INSERT OR REPLACE INTO templates (id, agent_id, name, subject, text_body, html_body) VALUES (?, ?, ?, ?, ?, ?)").run(id, req.agent.id, name2, subject || null, text || null, html || null);
-      res.json({ ok: true, id });
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.markUnseen(uid);
+      res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/templates/:id", requireAgent, async (req, res, next) => {
+  router.post("/mail/messages/:uid/move", requireAgent, async (req, res, next) => {
     try {
-      const result = db.prepare("DELETE FROM templates WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Template not found" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
+        return;
+      }
+      const { from: fromFolder, to: toFolder } = req.body || {};
+      if (!toFolder) {
+        res.status(400).json({ error: "to (destination folder) is required" });
         return;
       }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.moveMessage(uid, fromFolder || "INBOX", toFolder);
       res.json({ ok: true });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/scheduled", requireAgent, async (req, res, next) => {
+  router.get("/mail/folders", requireAgent, async (req, res, next) => {
     try {
-      const rows = db.prepare("SELECT * FROM scheduled_emails WHERE agent_id = ? ORDER BY send_at ASC").all(req.agent.id);
-      res.json({ scheduled: rows });
+      const agent = req.agent;
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const folders = await receiver.listFolders();
+      res.json({ folders });
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.post("/mail/folders", requireAgent, async (req, res, next) => {
+    try {
+      const agent = req.agent;
+      const { name } = req.body || {};
+      if (!name || typeof name !== "string" || !name.trim()) {
+        res.status(400).json({ error: "name is required" });
+        return;
+      }
+      if (name.length > 200 || /[\\*%]/.test(name)) {
+        res.status(400).json({ error: "Invalid folder name" });
+        return;
+      }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.createFolder(name);
+      res.json({ ok: true, folder: name });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/scheduled", requireAgent, async (req, res, next) => {
+  router.get("/mail/folders/:folder", requireAgent, async (req, res, next) => {
     try {
-      const { to, subject, text, html, cc, bcc, sendAt } = req.body || {};
-      if (!to || !subject || !sendAt) {
-        res.status(400).json({ error: "to, subject, and sendAt are required" });
-        return;
-      }
-      const sendDate = parseScheduleTime(String(sendAt));
-      if (!sendDate || isNaN(sendDate.getTime())) {
-        res.status(400).json({
-          error: "Invalid sendAt date. Accepted formats: ISO 8601 (2026-02-14T10:00:00), presets (in 30 minutes, in 1 hour, in 3 hours, tomorrow 8am, tomorrow 9am, next monday 9am), or MM-DD-YYYY H:MM AM/PM TZ"
-        });
-        return;
-      }
-      if (sendDate.getTime() <= Date.now()) {
-        res.status(400).json({ error: "sendAt must be in the future" });
+      const agent = req.agent;
+      const folder = decodeURIComponent(req.params.folder);
+      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 200);
+      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      let mailboxInfo;
+      try {
+        mailboxInfo = await receiver.getMailboxInfo(folder);
+      } catch {
+        res.json({ messages: [], count: 0, total: 0, folder });
         return;
       }
-      const id = uuidv4();
-      db.prepare(`INSERT INTO scheduled_emails (id, agent_id, to_addr, subject, text_body, html_body, cc, bcc, send_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, req.agent.id, to, subject, text || null, html || null, cc || null, bcc || null, sendDate.toISOString());
-      res.json({ ok: true, id, sendAt: sendDate.toISOString() });
+      const envelopes = await receiver.listEnvelopes(folder, { limit, offset });
+      res.json({ messages: envelopes, count: envelopes.length, total: mailboxInfo.exists, folder });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/scheduled/:id", requireAgent, async (req, res, next) => {
+  function validateUids(raw) {
+    if (!Array.isArray(raw) || raw.length === 0) return null;
+    if (raw.length > 1e3) return null;
+    const nums = raw.map(Number).filter((n) => Number.isInteger(n) && n > 0);
+    return nums.length > 0 ? nums : null;
+  }
+  router.post("/mail/batch/delete", requireAgent, async (req, res, next) => {
     try {
-      const result = db.prepare("DELETE FROM scheduled_emails WHERE id = ? AND agent_id = ? AND status = 'pending'").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Scheduled email not found or already sent" });
+      const agent = req.agent;
+      const { uids: rawUids, folder } = req.body || {};
+      const uids = validateUids(rawUids);
+      if (!uids) {
+        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
         return;
       }
-      res.json({ ok: true });
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.batchDelete(uids, folder || "INBOX");
+      res.json({ ok: true, deleted: uids.length });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/tags", requireAgent, async (req, res, next) => {
+  router.post("/mail/batch/seen", requireAgent, async (req, res, next) => {
     try {
-      const rows = db.prepare("SELECT * FROM tags WHERE agent_id = ? ORDER BY name").all(req.agent.id);
-      res.json({ tags: rows });
+      const agent = req.agent;
+      const { uids: rawUids, folder } = req.body || {};
+      const uids = validateUids(rawUids);
+      if (!uids) {
+        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
+        return;
+      }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.batchMarkSeen(uids, folder || "INBOX");
+      res.json({ ok: true, marked: uids.length });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/tags", requireAgent, async (req, res, next) => {
+  router.post("/mail/batch/unseen", requireAgent, async (req, res, next) => {
     try {
-      const { name: name2, color } = req.body || {};
-      if (!name2) {
-        res.status(400).json({ error: "name is required" });
+      const agent = req.agent;
+      const { uids: rawUids, folder } = req.body || {};
+      const uids = validateUids(rawUids);
+      if (!uids) {
+        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
         return;
       }
-      const id = uuidv4();
-      db.prepare("INSERT OR IGNORE INTO tags (id, agent_id, name, color) VALUES (?, ?, ?, ?)").run(id, req.agent.id, name2.trim(), color || "#888888");
-      res.json({ ok: true, id, name: name2.trim(), color: color || "#888888" });
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.batchMarkUnseen(uids, folder || "INBOX");
+      res.json({ ok: true, marked: uids.length });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/tags/:id", requireAgent, async (req, res, next) => {
+  router.post("/mail/batch/move", requireAgent, async (req, res, next) => {
     try {
-      const result = db.prepare("DELETE FROM tags WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Tag not found" });
+      const agent = req.agent;
+      const { uids: rawUids, from: fromFolder, to: toFolder } = req.body || {};
+      const uids = validateUids(rawUids);
+      if (!uids) {
+        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
         return;
       }
-      res.json({ ok: true });
+      if (!toFolder) {
+        res.status(400).json({ error: "to (destination folder) is required" });
+        return;
+      }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.batchMove(uids, fromFolder || "INBOX", toFolder);
+      res.json({ ok: true, moved: uids.length });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/tags/:id/messages", requireAgent, async (req, res, next) => {
+  router.post("/mail/batch/read", requireAgent, async (req, res, next) => {
     try {
-      const { uid, folder } = req.body || {};
-      if (!uid) {
-        res.status(400).json({ error: "uid is required" });
+      const agent = req.agent;
+      const { uids: rawUids, folder } = req.body || {};
+      const uids = validateUids(rawUids);
+      if (!uids) {
+        res.status(400).json({ error: "uids must be a non-empty array of positive integers (max 1000)" });
         return;
       }
-      const tag = db.prepare("SELECT * FROM tags WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
-      if (!tag) {
-        res.status(404).json({ error: "Tag not found" });
-        return;
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const rawMap = await receiver.batchFetch(uids, folder || "INBOX");
+      const messages = [];
+      for (const [uid, raw] of rawMap) {
+        const parsed = await parseEmail2(raw);
+        messages.push({ uid, ...parsed });
       }
-      db.prepare("INSERT OR IGNORE INTO message_tags (agent_id, message_uid, tag_id, folder) VALUES (?, ?, ?, ?)").run(req.agent.id, uid, req.params.id, folder || "INBOX");
-      res.json({ ok: true });
+      res.json({ messages, count: messages.length });
     } catch (err) {
       next(err);
     }
   });
-  router.delete("/tags/:id/messages/:uid", requireAgent, async (req, res, next) => {
+  router.get("/mail/spam", requireAgent, async (req, res, next) => {
     try {
-      const folder = req.query.folder || "INBOX";
-      db.prepare("DELETE FROM message_tags WHERE agent_id = ? AND message_uid = ? AND tag_id = ? AND folder = ?").run(req.agent.id, parseInt(String(req.params.uid)), req.params.id, folder);
-      res.json({ ok: true });
+      const agent = req.agent;
+      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 200);
+      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      let mailboxInfo;
+      try {
+        mailboxInfo = await receiver.getMailboxInfo("Spam");
+      } catch {
+        res.json({ messages: [], count: 0, total: 0, folder: "Spam" });
+        return;
+      }
+      const envelopes = await receiver.listEnvelopes("Spam", { limit, offset });
+      res.json({ messages: envelopes, count: envelopes.length, total: mailboxInfo.exists, folder: "Spam" });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/tags/:id/messages", requireAgent, async (req, res, next) => {
+  router.post("/mail/messages/:uid/spam", requireAgent, async (req, res, next) => {
     try {
-      const tag = db.prepare("SELECT * FROM tags WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
-      if (!tag) {
-        res.status(404).json({ error: "Tag not found" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
         return;
       }
-      const rows = db.prepare(
-        "SELECT message_uid, folder FROM message_tags WHERE agent_id = ? AND tag_id = ? ORDER BY created_at DESC"
-      ).all(req.agent.id, req.params.id);
-      res.json({ tag, messages: rows.map((r) => ({ uid: r.message_uid, folder: r.folder })) });
+      const folder = req.body?.folder || "INBOX";
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      try {
+        await receiver.createFolder("Spam");
+      } catch {
+      }
+      await receiver.moveMessage(uid, folder, "Spam");
+      res.json({ ok: true, movedToSpam: true });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/messages/:uid/tags", requireAgent, async (req, res, next) => {
+  router.post("/mail/messages/:uid/not-spam", requireAgent, async (req, res, next) => {
     try {
-      const rows = db.prepare(`
-        SELECT t.* FROM tags t
-        JOIN message_tags mt ON mt.tag_id = t.id
-        WHERE mt.agent_id = ? AND mt.message_uid = ?
-        ORDER BY t.name
-      `).all(req.agent.id, parseInt(String(req.params.uid)));
-      res.json({ tags: rows });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
+        return;
+      }
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      await receiver.moveMessage(uid, "Spam", "INBOX");
+      res.json({ ok: true, movedToInbox: true });
     } catch (err) {
       next(err);
     }
   });
-  router.post("/templates/:id/send", requireAgent, async (req, res, next) => {
+  router.get("/mail/messages/:uid/spam-score", requireAgent, async (req, res, next) => {
     try {
-      const template = db.prepare("SELECT * FROM templates WHERE id = ? AND agent_id = ?").get(req.params.id, req.agent.id);
-      if (!template) {
-        res.status(404).json({ error: "Template not found" });
+      const agent = req.agent;
+      const uid = parseInt(req.params.uid);
+      if (isNaN(uid) || uid < 1) {
+        res.status(400).json({ error: "Invalid UID" });
         return;
       }
-      const { to, variables, cc, bcc } = req.body || {};
-      if (!to) {
-        res.status(400).json({ error: "to is required" });
+      const folder = req.query.folder || "INBOX";
+      const password = getAgentPassword(agent);
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const raw = await receiver.fetchMessage(uid, folder);
+      const parsed = await parseEmail2(raw);
+      if (isInternalEmail2(parsed)) {
+        res.json({ score: 0, isSpam: false, isWarning: false, matches: [], topCategory: null, internal: true });
         return;
       }
-      const applyVars = (text, vars2) => text.replace(/\{\{(\w+)\}\}/g, (m, key) => vars2[key] ?? m);
-      const vars = variables && typeof variables === "object" ? variables : {};
-      const mailOpts = {
-        to,
-        subject: applyVars(template.subject || "(no subject)", vars),
-        text: template.text_body ? applyVars(template.text_body, vars) : void 0,
-        html: template.html_body ? applyVars(template.html_body, vars) : void 0,
-        cc: cc || void 0,
-        bcc: bcc || void 0
-      };
+      const result = scoreEmail2(parsed);
+      res.json(result);
+    } catch (err) {
+      next(err);
+    }
+  });
+  router.get("/mail/digest", requireAgent, async (req, res, next) => {
+    try {
       const agent = req.agent;
-      if (gatewayManager) {
-        const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
-        if (gatewayResult) {
-          res.json(gatewayResult);
-          return;
-        }
-      }
+      const limit = Math.min(Math.max(parseInt(req.query.limit) || 20, 1), 50);
+      const offset = Math.max(parseInt(req.query.offset) || 0, 0);
+      const previewLen = Math.min(Math.max(parseInt(req.query.previewLength) || 200, 50), 500);
+      const folder = req.query.folder || "INBOX";
       const password = getAgentPassword(agent);
-      const sender = new MailSender3({
-        host: config.smtp.host,
-        port: config.smtp.port,
-        email: agent.email,
-        password,
-        authUser: agent.stalwartPrincipal
-      });
-      try {
-        const result = await sender.send(mailOpts);
-        res.json(result);
-      } finally {
-        sender.close();
+      const receiver = await getReceiver(agent.stalwartPrincipal, password, config);
+      const mailboxInfo = await receiver.getMailboxInfo(folder);
+      const envelopes = await receiver.listEnvelopes(folder, { limit, offset });
+      const uids = envelopes.map((e) => e.uid);
+      const rawMap = uids.length > 0 ? await receiver.batchFetch(uids, folder) : /* @__PURE__ */ new Map();
+      const messages = [];
+      for (const env of envelopes) {
+        let preview = "";
+        const raw = rawMap.get(env.uid);
+        if (raw) {
+          const parsed = await parseEmail2(raw);
+          preview = (parsed.text || "").slice(0, previewLen);
+        }
+        messages.push({
+          uid: env.uid,
+          subject: env.subject,
+          from: env.from,
+          to: env.to,
+          date: env.date,
+          flags: [...env.flags],
+          size: env.size,
+          preview
+        });
       }
+      res.json({ messages, count: messages.length, total: mailboxInfo.exists });
     } catch (err) {
       next(err);
     }
   });
-  router.get("/rules", requireAgent, async (req, res, next) => {
-    try {
-      const rows = db.prepare("SELECT * FROM email_rules WHERE agent_id = ? ORDER BY priority DESC, created_at").all(req.agent.id);
-      res.json({ rules: rows.map((r) => ({ ...r, conditions: JSON.parse(r.conditions), actions: JSON.parse(r.actions) })) });
-    } catch (err) {
-      next(err);
+  router.get("/mail/pending", requireAuth, async (req, res) => {
+    const rows = req.isMaster ? db.prepare(
+      `SELECT id, agent_id, mail_options, warnings, summary, status, created_at, resolved_at, resolved_by
+           FROM pending_outbound ORDER BY created_at DESC LIMIT 50`
+    ).all() : db.prepare(
+      `SELECT id, agent_id, mail_options, warnings, summary, status, created_at, resolved_at, resolved_by
+           FROM pending_outbound WHERE agent_id = ? ORDER BY created_at DESC LIMIT 50`
+    ).all(req.agent.id);
+    const pending = rows.map((r) => {
+      const opts = JSON.parse(r.mail_options);
+      return {
+        id: r.id,
+        agentId: r.agent_id,
+        to: opts.to,
+        subject: opts.subject,
+        warnings: JSON.parse(r.warnings),
+        summary: r.summary,
+        status: r.status,
+        createdAt: r.created_at,
+        resolvedAt: r.resolved_at,
+        resolvedBy: r.resolved_by
+      };
+    });
+    res.json({ pending, count: pending.length });
+  });
+  router.get("/mail/pending/:id", requireAuth, async (req, res) => {
+    const row = req.isMaster ? db.prepare(`SELECT * FROM pending_outbound WHERE id = ?`).get(req.params.id) : db.prepare(`SELECT * FROM pending_outbound WHERE id = ? AND agent_id = ?`).get(req.params.id, req.agent.id);
+    if (!row) {
+      res.status(404).json({ error: "Pending email not found" });
+      return;
     }
+    res.json({
+      id: row.id,
+      mailOptions: JSON.parse(row.mail_options),
+      warnings: JSON.parse(row.warnings),
+      summary: row.summary,
+      status: row.status,
+      createdAt: row.created_at,
+      resolvedAt: row.resolved_at,
+      resolvedBy: row.resolved_by
+    });
   });
-  router.post("/rules", requireAgent, async (req, res, next) => {
+  router.post("/mail/pending/:id/approve", requireMaster, async (req, res, next) => {
     try {
-      const { name: name2, conditions, actions, priority, enabled } = req.body || {};
-      if (!name2) {
-        res.status(400).json({ error: "name is required" });
+      const row = db.prepare(
+        `SELECT * FROM pending_outbound WHERE id = ?`
+      ).get(req.params.id);
+      if (!row) {
+        res.status(404).json({ error: "Pending email not found" });
         return;
       }
-      const id = uuidv4();
-      db.prepare(
-        "INSERT INTO email_rules (id, agent_id, name, priority, enabled, conditions, actions) VALUES (?, ?, ?, ?, ?, ?, ?)"
-      ).run(id, req.agent.id, name2, priority ?? 0, enabled !== false ? 1 : 0, JSON.stringify(conditions || {}), JSON.stringify(actions || {}));
-      res.status(201).json({ id, name: name2, conditions: conditions || {}, actions: actions || {}, priority: priority ?? 0, enabled: enabled !== false });
-    } catch (err) {
-      next(err);
-    }
-  });
-  router.delete("/rules/:id", requireAgent, async (req, res, next) => {
-    try {
-      const result = db.prepare("DELETE FROM email_rules WHERE id = ? AND agent_id = ?").run(req.params.id, req.agent.id);
-      if (result.changes === 0) {
-        res.status(404).json({ error: "Rule not found" });
+      if (row.status !== "pending") {
+        res.status(400).json({ error: `Email already ${row.status}` });
         return;
       }
-      res.json({ ok: true });
-    } catch (err) {
-      next(err);
-    }
-  });
-  return router;
-}
-function evaluateRules(db, agentId, email) {
-  const rules = db.prepare("SELECT * FROM email_rules WHERE agent_id = ? AND enabled = 1 ORDER BY priority DESC").all(agentId);
-  for (const rule of rules) {
-    const cond = JSON.parse(rule.conditions);
-    let match = true;
-    const fromAddr = (email.from?.[0]?.address ?? "").toLowerCase();
-    const toAddr = (email.to?.[0]?.address ?? "").toLowerCase();
-    const subject = (email.subject ?? "").toLowerCase();
-    if (cond.from_contains && !fromAddr.includes(cond.from_contains.toLowerCase())) match = false;
-    if (cond.from_exact && fromAddr !== cond.from_exact.toLowerCase()) match = false;
-    if (cond.subject_contains && !subject.includes(cond.subject_contains.toLowerCase())) match = false;
-    if (cond.subject_regex) {
-      try {
-        if (!new RegExp(cond.subject_regex, "i").test(email.subject ?? "")) match = false;
-      } catch {
-        match = false;
+      const agent = await accountManager.getById(row.agent_id);
+      if (!agent) {
+        res.status(404).json({ error: "Agent account no longer exists" });
+        return;
       }
-    }
-    if (cond.to_contains && !toAddr.includes(cond.to_contains.toLowerCase())) match = false;
-    if (cond.has_attachment === true && (!email.attachments || email.attachments.length === 0)) match = false;
-    if (match) return { ruleId: rule.id, actions: JSON.parse(rule.actions) };
-  }
-  return null;
-}
-function startScheduledSender(db, accountManager, config, gatewayManager) {
-  return setInterval(async () => {
-    try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const pending = db.prepare(
-        "SELECT * FROM scheduled_emails WHERE status = 'pending' AND send_at <= ?"
-      ).all(now);
-      for (const row of pending) {
-        try {
-          const agent = await accountManager.getById(row.agent_id);
-          if (!agent) {
-            db.prepare("UPDATE scheduled_emails SET status = 'failed', error = ? WHERE id = ?").run("Agent not found", row.id);
-            continue;
-          }
-          const mailOpts = {
-            to: row.to_addr,
-            subject: row.subject,
-            text: row.text_body || void 0,
-            html: row.html_body || void 0,
-            cc: row.cc || void 0,
-            bcc: row.bcc || void 0
-          };
-          if (gatewayManager) {
-            const gResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
-            if (gResult) {
-              db.prepare("UPDATE scheduled_emails SET status = 'sent', sent_at = datetime('now') WHERE id = ?").run(row.id);
-              continue;
-            }
-          }
-          const password = agent.metadata?._password || agent.name;
-          const sender = new MailSender3({
-            host: config.smtp.host,
-            port: config.smtp.port,
-            email: agent.email,
-            password,
-            authUser: agent.stalwartPrincipal
-          });
-          try {
-            await sender.send(mailOpts);
-            db.prepare("UPDATE scheduled_emails SET status = 'sent', sent_at = datetime('now') WHERE id = ?").run(row.id);
-          } finally {
-            sender.close();
+      const mailOpts = JSON.parse(row.mail_options);
+      const ownerName = agent.metadata?.ownerName;
+      mailOpts.fromName = ownerName ? `${agent.name} from ${ownerName}` : agent.name;
+      if (Array.isArray(mailOpts.attachments)) {
+        for (const att of mailOpts.attachments) {
+          if (att.content && typeof att.content === "object" && att.content.type === "Buffer" && Array.isArray(att.content.data)) {
+            att.content = Buffer.from(att.content.data);
           }
-        } catch (err) {
-          db.prepare("UPDATE scheduled_emails SET status = 'failed', error = ? WHERE id = ?").run(err.message, row.id);
         }
       }
-      try {
-        db.prepare("DELETE FROM delivered_messages WHERE delivered_at < datetime('now', '-30 days')").run();
-      } catch {
+      const password = getAgentPassword(agent);
+      let response;
+      if (gatewayManager) {
+        const gatewayResult = await gatewayManager.routeOutbound(agent.name, mailOpts);
+        if (gatewayResult) {
+          if (gatewayResult.raw) {
+            saveSentCopy(agent.stalwartPrincipal, password, config, gatewayResult.raw);
+          }
+          const { raw: _raw, ...rest } = gatewayResult;
+          response = rest;
+        }
       }
-      try {
-        db.prepare("DELETE FROM spam_log WHERE created_at < datetime('now', '-30 days')").run();
-      } catch {
+      if (!response) {
+        const sender = getSender(agent.stalwartPrincipal, agent.email, password, config);
+        const result = await sender.send(mailOpts);
+        saveSentCopy(agent.stalwartPrincipal, password, config, result.raw);
+        notifyLocalRecipientsOfNewMail(
+          accountManager,
+          mailOpts.to,
+          mailOpts.cc,
+          mailOpts.bcc,
+          agent,
+          mailOpts.subject,
+          result.messageId
+        ).catch((err) => {
+          console.warn(`[mail] Internal SSE notify (approve) failed: ${err.message}`);
+        });
+        const { raw: _raw, ...rest } = result;
+        response = rest;
       }
-    } catch {
-    }
-  }, 3e4);
-}
-
-// src/routes/events.ts
-var MAX_SSE_PER_AGENT = 5;
-var activeWatchers = /* @__PURE__ */ new Map();
-function pushEventToAgent(agentId, event) {
-  const watchers = activeWatchers.get(agentId);
-  if (!watchers || watchers.size === 0) return false;
-  const data = `data: ${JSON.stringify(event)}
-
-`;
-  for (const entry of watchers) {
-    try {
-      entry.res.write(data);
-    } catch {
+      db.prepare(
+        `UPDATE pending_outbound SET status = 'approved', resolved_at = datetime('now'), resolved_by = ? WHERE id = ?`
+      ).run("master", row.id);
+      res.json({ ...response, approved: true, pendingId: row.id });
+    } catch (err) {
+      next(err);
     }
-  }
-  return true;
-}
-function broadcastEvent(event) {
-  const data = `data: ${JSON.stringify(event)}
-
-`;
-  let count = 0;
-  for (const [, watchers] of activeWatchers) {
-    for (const entry of watchers) {
-      try {
-        entry.res.write(data);
-        count++;
-      } catch {
-      }
+  });
+  router.post("/mail/pending/:id/reject", requireMaster, async (req, res) => {
+    const row = db.prepare(
+      `SELECT * FROM pending_outbound WHERE id = ?`
+    ).get(req.params.id);
+    if (!row) {
+      res.status(404).json({ error: "Pending email not found" });
+      return;
     }
-  }
-  return count;
-}
-async function closeAllWatchers() {
-  for (const [, watchers] of activeWatchers) {
-    for (const entry of watchers) {
-      try {
-        await entry.watcher.stop();
-      } catch {
-      }
-      try {
-        entry.res.end();
-      } catch {
-      }
+    if (row.status !== "pending") {
+      res.status(400).json({ error: `Email already ${row.status}` });
+      return;
     }
-  }
-  activeWatchers.clear();
+    db.prepare(
+      `UPDATE pending_outbound SET status = 'rejected', resolved_at = datetime('now'), resolved_by = ? WHERE id = ?`
+    ).run("master", row.id);
+    res.json({ ok: true, rejected: true, pendingId: row.id });
+  });
+  return router;
 }
-function createEventRoutes(accountManager, config, db) {
+
+// src/routes/inbound.ts
+import { Router as Router6 } from "express";
+import { randomUUID } from "crypto";
+import {
+  parseEmail as parseEmail3,
+  MailSender as MailSender3
+} from "@agenticmail/core";
+var INBOUND_SECRET = process.env.AGENTICMAIL_INBOUND_SECRET || (() => {
+  const generated = randomUUID();
+  console.warn("[Inbound] WARNING: AGENTICMAIL_INBOUND_SECRET is not set. Generated a random secret for this session.");
+  console.warn(`[Inbound] Set AGENTICMAIL_INBOUND_SECRET="${generated}" in your environment to persist it across restarts.`);
+  return generated;
+})();
+var DEBUG = () => !!process.env.AGENTICMAIL_DEBUG;
+function createInboundRoutes(accountManager, config, gatewayManager) {
   const router = Router6();
-  router.get("/events", requireAgent, async (req, res, next) => {
+  router.post("/mail/inbound", async (req, res, next) => {
     try {
-      const agent = req.agent;
-      const password = getAgentPassword(agent);
-      const agentWatchers = activeWatchers.get(agent.id) ?? /* @__PURE__ */ new Set();
-      if (agentWatchers.size >= MAX_SSE_PER_AGENT) {
-        res.status(429).json({ error: `Maximum ${MAX_SSE_PER_AGENT} concurrent SSE connections per agent` });
+      const secret = req.headers["x-inbound-secret"];
+      if (secret !== INBOUND_SECRET) {
+        res.status(401).json({ error: "Invalid inbound secret" });
         return;
       }
-      const watcher = new InboxWatcher({
-        host: config.imap.host,
-        port: config.imap.port,
-        email: agent.stalwartPrincipal,
-        password,
-        autoReconnect: true,
-        maxReconnectAttempts: 20
-      });
-      try {
-        await watcher.start();
-      } catch (err) {
-        res.status(500).json({ error: "Failed to start event stream: " + (err instanceof Error ? err.message : String(err)) });
+      const { from, to, subject, rawEmail } = req.body;
+      if (!to || !rawEmail) {
+        res.status(400).json({ error: "to and rawEmail are required" });
         return;
       }
-      res.setHeader("Content-Type", "text/event-stream");
-      res.setHeader("Cache-Control", "no-cache");
-      res.setHeader("Connection", "keep-alive");
-      res.setHeader("X-Accel-Buffering", "no");
-      res.flushHeaders();
-      let closed = false;
-      const entry = { watcher, res };
-      activeWatchers.set(agent.id, agentWatchers);
-      agentWatchers.add(entry);
-      const safeWrite = (data) => {
-        if (!closed) {
-          try {
-            res.write(data);
-          } catch {
-          }
-        }
-      };
-      safeWrite(`data: ${JSON.stringify({ type: "connected", agentId: agent.id })}
-
-`);
-      watcher.on("new", async (event) => {
-        if (db) touchActivity(db, agent.id);
-        if (db && event.uid) {
-          try {
-            const receiver = new MailReceiver2({
-              host: config.imap.host,
-              port: config.imap.port,
-              email: agent.stalwartPrincipal,
-              password,
-              secure: false
-            });
-            await receiver.connect();
-            try {
-              const raw = await receiver.fetchMessage(event.uid);
-              const parsed = await parseEmail3(raw);
-              const policyMetadata = agent.metadata && typeof agent.metadata === "object" ? {
-                emailRoutePolicy: agent.metadata.emailRoutePolicy,
-                routePolicy: agent.metadata.routePolicy,
-                mailboxPolicy: agent.metadata.mailboxPolicy
-              } : void 0;
-              const accountRouteContext = {
-                name: agent.name,
-                email: agent.email,
-                role: agent.role,
-                metadata: policyMetadata
-              };
-              const isRelay = !!parsed.headers.get("x-agenticmail-relay");
-              const internal = !isRelay && isInternalEmail2(parsed);
-              if (internal) {
-                event.route = classifyEmailRoute({ email: parsed, account: accountRouteContext });
-                const ruleResult2 = evaluateRules(db, agent.id, parsed);
-                if (ruleResult2) {
-                  const actions = ruleResult2.actions;
-                  if (actions.mark_read) await receiver.markSeen(event.uid);
-                  if (actions.delete) {
-                    await receiver.deleteMessage(event.uid);
-                    return;
-                  }
-                  if (actions.move_to) await receiver.moveMessage(event.uid, "INBOX", actions.move_to);
-                  event.ruleApplied = { ruleId: ruleResult2.ruleId, actions };
-                }
-                safeWrite(`data: ${JSON.stringify(event)}
-
-`);
-                return;
-              }
-              const spamResult = scoreEmail2(parsed);
-              event.route = classifyEmailRoute({ email: parsed, spam: spamResult, account: accountRouteContext });
-              try {
-                db.prepare(
-                  "INSERT INTO spam_log (id, agent_id, message_uid, score, flags, category, is_spam) VALUES (?, ?, ?, ?, ?, ?, ?)"
-                ).run(
-                  uuidv42(),
-                  agent.id,
-                  event.uid,
-                  spamResult.score,
-                  JSON.stringify(spamResult.matches.map((m) => m.ruleId)),
-                  spamResult.topCategory,
-                  spamResult.isSpam ? 1 : 0
-                );
-              } catch {
-              }
-              if (spamResult.isSpam) {
-                try {
-                  await receiver.createFolder("Spam");
-                } catch {
-                }
-                await receiver.moveMessage(event.uid, "INBOX", "Spam");
-                event.spam = { score: spamResult.score, category: spamResult.topCategory, movedToSpam: true };
-                safeWrite(`data: ${JSON.stringify(event)}
-
-`);
-                return;
-              }
-              if (spamResult.isWarning) {
-                event.spamWarning = { score: spamResult.score, category: spamResult.topCategory, matches: spamResult.matches.map((m) => m.ruleId) };
-              }
-              const ruleResult = evaluateRules(db, agent.id, parsed);
-              if (ruleResult) {
-                const actions = ruleResult.actions;
-                if (actions.mark_read) await receiver.markSeen(event.uid);
-                if (actions.delete) {
-                  await receiver.deleteMessage(event.uid);
-                  return;
-                }
-                if (actions.move_to) await receiver.moveMessage(event.uid, "INBOX", actions.move_to);
-                event.ruleApplied = { ruleId: ruleResult.ruleId, actions };
-              }
-            } finally {
-              await receiver.disconnect();
-            }
-          } catch (err) {
-            console.error("[SSE] Spam/rule evaluation error:", err.message);
-          }
-        }
-        safeWrite(`data: ${JSON.stringify(event)}
-
-`);
-      });
-      watcher.on("expunge", (event) => {
-        safeWrite(`data: ${JSON.stringify(event)}
-
-`);
-      });
-      watcher.on("flags", (event) => {
-        safeWrite(`data: ${JSON.stringify(event)}
-
-`);
-      });
-      watcher.on("error", (err) => {
-        safeWrite(`data: ${JSON.stringify({ type: "error", message: err.message })}
-
-`);
-      });
-      watcher.on("reconnecting", (info) => {
-        safeWrite(`data: ${JSON.stringify({ type: "reconnecting", attempt: info.attempt, delayMs: info.delayMs })}
-
-`);
-      });
-      watcher.on("reconnected", (info) => {
-        safeWrite(`data: ${JSON.stringify({ type: "reconnected", attempt: info.attempt })}
-
-`);
-      });
-      watcher.on("reconnect_failed", (info) => {
-        safeWrite(`data: ${JSON.stringify({ type: "reconnect_failed", attempts: info.attempts })}
-
-`);
+      const recipientEmail = typeof to === "string" ? to : to[0];
+      const localPart = recipientEmail.split("@")[0];
+      const agent = await accountManager.getByName(localPart);
+      if (!agent) {
+        console.warn(`[Inbound] No agent found for "${localPart}" (${recipientEmail})`);
+        res.status(404).json({ error: `No agent found for ${recipientEmail}` });
+        return;
+      }
+      const agentPassword = agent.metadata?._password;
+      if (!agentPassword) {
+        console.warn(`[Inbound] No password for agent "${agent.name}"`);
+        res.status(500).json({ error: "Agent has no password configured" });
+        return;
+      }
+      const rawBuffer = Buffer.from(rawEmail, "base64");
+      const parsed = await parseEmail3(rawBuffer);
+      const originalMessageId = parsed.messageId;
+      if (originalMessageId && gatewayManager?.isAlreadyDelivered(originalMessageId, agent.name)) {
+        if (DEBUG()) console.log(`[Inbound] Skipping duplicate: ${originalMessageId} \u2192 ${agent.name}`);
+        res.json({ ok: true, delivered: agent.email, duplicate: true });
+        return;
+      }
+      if (DEBUG()) console.log(`[Inbound] Delivering email to ${agent.email} from ${from} (subject: ${subject || parsed.subject})`);
+      const sender = new MailSender3({
+        host: config.smtp.host,
+        port: config.smtp.port,
+        email: agent.email,
+        password: agentPassword,
+        authUser: agent.stalwartPrincipal
       });
-      const pingInterval = setInterval(() => {
-        safeWrite(`: ping
-
-`);
-      }, 3e4);
-      req.on("close", () => {
-        closed = true;
-        clearInterval(pingInterval);
-        agentWatchers.delete(entry);
-        if (agentWatchers.size === 0) activeWatchers.delete(agent.id);
-        watcher.removeAllListeners();
-        watcher.stop().catch((err) => {
-          console.error("[SSE] Watcher cleanup error:", err);
+      try {
+        await sender.send({
+          to: agent.email,
+          subject: parsed.subject || subject || "(no subject)",
+          text: parsed.text || void 0,
+          html: parsed.html || void 0,
+          replyTo: from || parsed.from?.[0]?.address,
+          inReplyTo: parsed.inReplyTo,
+          references: parsed.references,
+          headers: {
+            "X-AgenticMail-Inbound": "cloudflare-worker",
+            "X-Original-From": from || parsed.from?.[0]?.address || "",
+            ...parsed.messageId ? { "X-Original-Message-Id": parsed.messageId } : {}
+          },
+          attachments: parsed.attachments?.map((a) => ({
+            filename: a.filename,
+            content: a.content,
+            contentType: a.contentType
+          }))
         });
-      });
+        if (originalMessageId) gatewayManager?.recordDelivery(originalMessageId, agent.name);
+        if (DEBUG()) console.log(`[Inbound] Delivered to ${agent.email}`);
+        res.json({ ok: true, delivered: agent.email });
+      } finally {
+        sender.close();
+      }
     } catch (err) {
       next(err);
     }
@@ -3402,7 +3474,14 @@ function buildColumnDDL(col, dialect) {
   if (col.required && !col.primaryKey) ddl += " NOT NULL";
   if (col.unique && !col.primaryKey) ddl += " UNIQUE";
   if (col.default !== void 0) {
-    const val = typeof col.default === "string" ? `'${col.default}'` : col.default;
+    let val;
+    if (typeof col.default === "string") {
+      const trimmed = col.default.trim();
+      const isSqlExpr = /\(.*\)/.test(trimmed) || /^CURRENT_(?:TIMESTAMP|DATE|TIME)$/i.test(trimmed);
+      val = isSqlExpr ? `(${trimmed})` : `'${col.default.replace(/'/g, "''")}'`;
+    } else {
+      val = col.default;
+    }
     ddl += ` DEFAULT ${val}`;
   }
   if (col.check) ddl += ` CHECK (${col.check})`;
@@ -3412,15 +3491,15 @@ function buildColumnDDL(col, dialect) {
   }
   return ddl;
 }
-function safeTableName(agentId, name2, shared) {
-  const clean = name2.replace(/[^a-zA-Z0-9_]/g, "").substring(0, 64);
+function safeTableName(agentId, name, shared) {
+  const clean = name.replace(/[^a-zA-Z0-9_]/g, "").substring(0, 64);
   if (!clean) throw new Error("Invalid table name");
   const prefix = shared ? "shared" : `agt_${agentId.replace(/[^a-zA-Z0-9]/g, "").substring(0, 16)}`;
   return `${prefix}_${clean}`;
 }
-function resolveTable(agentId, name2) {
-  if (name2.startsWith("agt_") || name2.startsWith("shared_")) return name2;
-  return safeTableName(agentId, name2, false);
+function resolveTable(agentId, name) {
+  if (name.startsWith("agt_") || name.startsWith("shared_")) return name;
+  return safeTableName(agentId, name, false);
 }
 function isSafeTable(tableName) {
   return tableName.startsWith("agt_") || tableName.startsWith("shared_");
@@ -3578,8 +3657,8 @@ function createStorageRoutes(rawDb, accountManager, config, dialect = "sqlite")
     if (!agent) return;
     await ensureMetaTable();
     try {
-      const { name: name2, columns, indexes, shared, description, timestamps } = req.body;
-      if (!name2 || !columns?.length) return res.status(400).json({ error: "name and columns are required" });
+      const { name, columns, indexes, shared, description, timestamps } = req.body;
+      if (!name || !columns?.length) return res.status(400).json({ error: "name and columns are required" });
       const hasPK = columns.some((c) => c.primaryKey);
       const allCols = [...hasPK ? [] : [{ name: "id", type: "text", primaryKey: true }], ...columns];
       if (timestamps !== false) {
@@ -3590,9 +3669,9 @@ function createStorageRoutes(rawDb, accountManager, config, dialect = "sqlite")
           allCols.push({ name: "updated_at", type: "timestamp", default: nowExpr(dialect) });
         }
       }
-      const tableName = safeTableName(agent.id, name2, !!shared);
+      const tableName = safeTableName(agent.id, name, !!shared);
       const existing = await db.get("SELECT table_name FROM agenticmail_storage_meta WHERE table_name = ?", [tableName]);
-      if (existing) return res.status(409).json({ error: `Table "${name2}" already exists`, table: tableName });
+      if (existing) return res.status(409).json({ error: `Table "${name}" already exists`, table: tableName });
       const colDefs = allCols.map((c) => buildColumnDDL(c, dialect)).join(",\n  ");
       await db.run(`CREATE TABLE IF NOT EXISTS ${tableName} (
   ${colDefs}
@@ -3613,7 +3692,7 @@ function createStorageRoutes(rawDb, accountManager, config, dialect = "sqlite")
       }
       await db.run(
         "INSERT INTO agenticmail_storage_meta (table_name, agent_id, display_name, description, shared, columns, indexes) VALUES (?, ?, ?, ?, ?, ?, ?)",
-        [tableName, agent.id, name2, description || "", shared ? 1 : 0, JSON.stringify(allCols), JSON.stringify(idxMeta)]
+        [tableName, agent.id, name, description || "", shared ? 1 : 0, JSON.stringify(allCols), JSON.stringify(idxMeta)]
       );
       res.json({ ok: true, table: tableName, columns: allCols, indexes: idxMeta });
     } catch (err) {