apple-mail-mcp 2.4.2 → 2.6.0

package/build/index.js

@@ -26,9 +26,11 @@ import { z } from "zod";
 import { AppleMailManager, isPathWithinAllowedRoots } from "./services/appleMailManager.js";
 import { writeFileSync } from "fs";
 import { resolve as resolvePath, join as joinPath } from "path";
-import { sendViaSmtp, shouldUseSmtp } from "./services/smtpMailer.js";
-import { isImapAccount, resolveImapConfigs, dropAllPools, imapSearchMessages, imapListMessages, imapUnreadCount, imapListMailboxes, imapMailStats, imapListAttachments, imapFetchAttachment, imapBatchMarkRead, imapBatchMarkUnread, imapBatchFlag, imapBatchUnflag, imapBatchDelete, imapBatchMove, imapThread, imapCreateMailbox, imapDeleteMailbox, imapRenameMailbox, imapGetMessage, imapMarkRead, imapMarkUnread, imapFlagMessage, imapUnflagMessage, imapMoveMessageById, imapDeleteMessageById, } from "./services/imapClient.js";
+import { sendViaSmtp, sendSerialViaSmtp, shouldUseSmtp, isSmtpConfigured, resolveSmtpConfig, } from "./services/smtpMailer.js";
+import { buildReplyOptions, buildForwardOptions, parseOriginalHeaders, } from "./services/replyForward.js";
+import { isImapAccount, shouldUseImap, resolveImapConfigs, dropAllPools, imapSearchMessages, imapListMessages, imapUnreadCount, imapListMailboxes, imapMailStats, imapListAttachments, imapFetchAttachment, imapBatchMarkRead, imapBatchMarkUnread, imapBatchFlag, imapBatchUnflag, imapBatchDelete, imapBatchMove, imapThread, imapCreateMailbox, imapDeleteMailbox, imapRenameMailbox, imapGetMessage, imapMarkRead, imapMarkUnread, imapFlagMessage, imapUnflagMessage, imapMoveMessageById, imapDeleteMessageById, } from "./services/imapClient.js";
 import { successResponse, errorResponse, partialCoverageBlock, withErrorHandling, messageSummary, } from "./tools/respond.js";
+import { fanOutImapMessages, mergeMessages, formatMergedRows, partitionAccountsForCounts, planCountSources, } from "./services/imapMultiAccount.js";
 import { routeMessage } from "./services/messageRouter.js";
 import { runDoctor, formatDoctorReport } from "./tools/doctor.js";
 import { registerResourcesAndPrompts } from "./tools/resourcesAndPrompts.js";
@@ -115,6 +117,83 @@ const CHECK_ITEM_SCHEMA = z.object({}).passthrough();
 // Read version from package.json to keep it in sync
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
+/** An empty SearchDiagnostics (complete coverage). */
+function emptyDiagnostics() {
+    return {
+        partial: false,
+        timedOutAccounts: [],
+        skippedLargeMailboxes: [],
+        notSearchedMailboxes: [],
+    };
+}
+/** Merge two diagnostics objects (union the lists, OR the partial flag). */
+function mergeDiagnostics(a, b) {
+    return {
+        partial: a.partial || b.partial,
+        timedOutAccounts: [...a.timedOutAccounts, ...b.timedOutAccounts],
+        skippedLargeMailboxes: [...a.skippedLargeMailboxes, ...b.skippedLargeMailboxes],
+        notSearchedMailboxes: [...a.notSearchedMailboxes, ...b.notSearchedMailboxes],
+    };
+}
+/**
+ * Run a per-account AppleScript scan over ONLY the given accounts (the ones no
+ * IMAP config covers), concatenating their rows and merging diagnostics. The IMAP
+ * fan-out already covers the IMAP accounts, so this avoids scanning them on the
+ * AppleScript side — which, for an all-IMAP user, means ZERO AppleScript work and
+ * therefore no reliance on the fragile composite dedup. `scan` runs one account.
+ */
+function appleScanForAccounts(accounts, scan) {
+    const rows = [];
+    let diagnostics = emptyDiagnostics();
+    for (const acct of accounts) {
+        const res = scan(acct.name);
+        rows.push(...res.messages.map(messageSummary));
+        diagnostics = mergeDiagnostics(diagnostics, res.diagnostics);
+    }
+    return { rows, diagnostics };
+}
+/**
+ * Build the success response for a no-account, prefer-IMAP MERGED message list
+ * (search-messages / list-messages — v2.6.0). Concatenates the IMAP fan-out rows
+ * with the (already partitioned) AppleScript rows, de-dups (IMAP copy wins — a
+ * safety net for heuristic misses + IMAP-vs-IMAP dupes, no longer load-bearing
+ * for matched accounts), sorts newest-first, applies `limit`, and preserves the
+ * partial-coverage diagnostics (AppleScript scan + any failed IMAP fan-out).
+ *
+ * @param verb "matched" (search) or "listed" (list) — only affects empty-state text.
+ */
+function mergedMessageResponse(fan, apple, limit, verb) {
+    const merged = mergeMessages(fan.rows, apple.rows, limit);
+    // Surface IMAP fan-out failures alongside the AppleScript diagnostics so a
+    // partial merge is never mistaken for a confirmed "no such mail".
+    const diagnostics = {
+        ...apple.diagnostics,
+        partial: apple.diagnostics.partial || fan.accountsFailed.length > 0,
+        timedOutAccounts: [...apple.diagnostics.timedOutAccounts, ...fan.accountsFailed],
+    };
+    const structured = {
+        messages: merged,
+        count: merged.length,
+        partial: diagnostics.partial,
+        skippedLargeMailboxes: diagnostics.skippedLargeMailboxes,
+        notSearchedMailboxes: diagnostics.notSearchedMailboxes,
+        timedOutAccounts: diagnostics.timedOutAccounts,
+    };
+    const coverageBlock = partialCoverageBlock(diagnostics);
+    if (merged.length === 0) {
+        const base = diagnostics.partial
+            ? `No messages found in the portions that were ${verb === "matched" ? "searched" : "listed"}.`
+            : "No messages found";
+        return successResponse(`${base}${coverageBlock}`, structured);
+    }
+    const parts = [];
+    if (fan.accountsQueried.length > 0)
+        parts.push(`IMAP account(s): ${fan.accountsQueried.join(", ")}`);
+    if (apple.rows.length > 0)
+        parts.push("AppleScript");
+    const accountsNote = parts.length > 0 ? ` (merged across ${parts.join(" + ")})` : "";
+    return successResponse(`Found ${merged.length} message(s)${accountsNote}:\n${formatMergedRows(merged)}${coverageBlock}`, structured);
+}
 // =============================================================================
 // Server Initialization
 // =============================================================================
@@ -189,13 +268,17 @@ server.registerTool("search-messages", {
     },
     outputSchema: LIST_OUTPUT_SCHEMA,
 }, withErrorHandling(async ({ query, mailbox, account, limit = 50, dateFrom, dateTo, from, subject, isRead, isFlagged, }) => {
-    // IMAP backend (issue #43): server-side search when this account is
-    // explicitly configured for IMAP; otherwise fall through to AppleScript.
-    if (isImapAccount(account)) {
-        const r = await imapSearchMessages({
+    // IMAP backend: prefer direct IMAP whenever IMAP is configured (v2.6.0).
+    //   - explicit IMAP account → single-account IMAP (fast path);
+    //   - no account + IMAP configured → MERGE: IMAP fans out over every
+    //     configured account; AppleScript scans ONLY the accounts no IMAP
+    //     config covers (partitioned — so an all-IMAP user runs ZERO
+    //     AppleScript and never relies on the composite dedup);
+    //   - explicit non-IMAP account (or IMAP unconfigured) → AppleScript below.
+    if (shouldUseImap(account)) {
+        const imapArgs = {
             query,
             mailbox,
-            account,
             limit,
             dateFrom,
             dateTo,
@@ -203,12 +286,19 @@ server.registerTool("search-messages", {
             subject,
             isRead,
             isFlagged,
-        });
-        return successResponse(r.text, {
-            messages: r.messages,
-            count: r.count,
-            partial: r.partial,
-        });
+        };
+        if (account !== undefined) {
+            const r = await imapSearchMessages({ ...imapArgs, account });
+            return successResponse(r.text, {
+                messages: r.messages,
+                count: r.count,
+                partial: r.partial,
+            });
+        }
+        const fan = await fanOutImapMessages(imapArgs, "search");
+        const { appleScriptOnly } = partitionAccountsForCounts(mailManager.listAccounts(), resolveImapConfigs());
+        const apple = appleScanForAccounts(appleScriptOnly, (acctName) => mailManager.searchMessagesWithDiagnostics(query, mailbox, acctName, limit, dateFrom, dateTo, from, subject, isRead, isFlagged));
+        return mergedMessageResponse(fan, apple, limit, "matched");
     }
     const { messages, diagnostics } = mailManager.searchMessagesWithDiagnostics(query, mailbox, account, limit, dateFrom, dateTo, from, subject, isRead, isFlagged);
     const coverageBlock = partialCoverageBlock(diagnostics);
@@ -322,15 +412,48 @@ server.registerTool("get-thread", {
     if (!seedSubject)
         return errorResponse(`Could not determine the subject of message "${id}"`);
     const base = normalizeSubject(seedSubject);
-    // IMAP backend: server-side subject search.
-    if (isImapAccount(account)) {
-        const r = await imapSearchMessages({ subject: base, mailbox, account, limit });
-        return successResponse(`Thread "${base}":\n${r.text}`, {
-            subject: base,
-            messages: r.messages,
-            count: r.count,
-            partial: r.partial,
+    // IMAP backend: server-side subject search (prefer-IMAP, v2.6.0).
+    //   - explicit IMAP account → single-account IMAP subject search;
+    //   - no account + IMAP configured → MERGE: IMAP fan-out subject search over
+    //     every configured account + AppleScript subject search over ONLY the
+    //     accounts no IMAP config covers (partitioned), then re-order oldest-
+    //     first for natural thread reading.
+    if (shouldUseImap(account)) {
+        if (account !== undefined) {
+            const r = await imapSearchMessages({ subject: base, mailbox, account, limit });
+            return successResponse(`Thread "${base}":\n${r.text}`, {
+                subject: base,
+                messages: r.messages,
+                count: r.count,
+                partial: r.partial,
+            });
+        }
+        const fan = await fanOutImapMessages({ subject: base, mailbox, limit }, "search");
+        const { appleScriptOnly } = partitionAccountsForCounts(mailManager.listAccounts(), resolveImapConfigs());
+        const apple = appleScanForAccounts(appleScriptOnly, (acctName) => mailManager.searchMessagesWithDiagnostics(undefined, mailbox, acctName, limit, undefined, undefined, undefined, base));
+        // Merge + de-dup (IMAP wins), then sort OLDEST-first for thread order.
+        const mergedNewestFirst = mergeMessages(fan.rows, apple.rows, limit);
+        const orderedRows = mergedNewestFirst
+            .slice()
+            .reverse() // mergeMessages returns newest-first; threads read oldest-first
+            .sort((a, b) => (a.dateReceived ? new Date(a.dateReceived).getTime() : 0) -
+            (b.dateReceived ? new Date(b.dateReceived).getTime() : 0));
+        const partial = apple.diagnostics.partial || fan.accountsFailed.length > 0;
+        const coverage = partialCoverageBlock({
+            ...apple.diagnostics,
+            partial,
+            timedOutAccounts: [...apple.diagnostics.timedOutAccounts, ...fan.accountsFailed],
         });
+        const structured = {
+            subject: base,
+            messages: orderedRows,
+            count: orderedRows.length,
+            partial,
+        };
+        if (orderedRows.length === 0) {
+            return successResponse(`No messages found in thread "${base}".${coverage}`, structured);
+        }
+        return successResponse(`Thread "${base}" — ${orderedRows.length} message(s), oldest first:\n${formatMergedRows(orderedRows)}${coverage}`, structured);
     }
     const { messages, diagnostics } = mailManager.searchMessagesWithDiagnostics(undefined, mailbox, account, limit, undefined, undefined, undefined, base);
     // Oldest-first is the natural reading order for a conversation.
@@ -368,15 +491,27 @@ server.registerTool("list-messages", {
     },
     outputSchema: LIST_OUTPUT_SCHEMA,
 }, withErrorHandling(async ({ mailbox, account, limit = 50, offset = 0, from, unreadOnly }) => {
-    // IMAP backend (issue #43): server-side listing when this account is
-    // explicitly configured for IMAP; otherwise fall through to AppleScript.
-    if (isImapAccount(account)) {
-        const r = await imapListMessages({ mailbox, account, limit, offset, from, unreadOnly });
-        return successResponse(r.text, {
-            messages: r.messages,
-            count: r.count,
-            partial: r.partial,
-        });
+    // IMAP backend: prefer direct IMAP whenever IMAP is configured (v2.6.0).
+    //   - explicit IMAP account → single-account IMAP listing (fast path);
+    //   - no account + IMAP configured → MERGE: IMAP fans out over every
+    //     configured account; AppleScript lists ONLY the accounts no IMAP config
+    //     covers (partitioned — all-IMAP user runs ZERO AppleScript). NOTE:
+    //     pagination via `offset` is applied PER-BACKEND before the merge, so
+    //     deep offsets in a merged multi-account list are approximate — recommend
+    //     scoping with an `account` for exact pagination.
+    if (shouldUseImap(account)) {
+        if (account !== undefined) {
+            const r = await imapListMessages({ mailbox, account, limit, offset, from, unreadOnly });
+            return successResponse(r.text, {
+                messages: r.messages,
+                count: r.count,
+                partial: r.partial,
+            });
+        }
+        const fan = await fanOutImapMessages({ mailbox, limit, offset, from, unreadOnly }, "list");
+        const { appleScriptOnly } = partitionAccountsForCounts(mailManager.listAccounts(), resolveImapConfigs());
+        const apple = appleScanForAccounts(appleScriptOnly, (acctName) => mailManager.listMessagesWithDiagnostics(mailbox, acctName, limit, from, offset));
+        return mergedMessageResponse(fan, apple, limit, "listed");
     }
     const { messages, diagnostics } = mailManager.listMessagesWithDiagnostics(mailbox, account, limit, from, offset);
     const coverageBlock = partialCoverageBlock(diagnostics);
@@ -504,8 +639,13 @@ server.registerTool("send-serial-email", {
             .passthrough())
             .optional(),
     },
-}, withErrorHandling(({ recipients, subject, body, account, delayMs }) => {
-    const results = mailManager.sendSerialEmail(recipients, subject, body, account, delayMs);
+}, withErrorHandling(async ({ recipients, subject, body, account, delayMs }) => {
+    // 2.5.0: prefer direct SMTP for mail-merge when configured (and not targeting
+    // a bare Mail.app account label); Mail.app fallback when not configured.
+    const smtpCfg = shouldUseSmtp(undefined, account) ? resolveSmtpOrFallback() : null;
+    const results = smtpCfg
+        ? await sendSerialViaSmtp(recipients, subject, body, smtpCfg, { delayMs })
+        : mailManager.sendSerialEmail(recipients, subject, body, account, delayMs);
     const successCount = results.filter((r) => r.success).length;
     const failCount = results.length - successCount;
     const details = results
@@ -557,6 +697,64 @@ server.registerTool("create-draft", {
         attachmentCount,
     });
 }, "Error creating draft"));
+/** Resolve SMTP config, falling back (host/user set but no password) to Mail.app. */
+function resolveSmtpOrFallback() {
+    try {
+        return resolveSmtpConfig();
+    }
+    catch {
+        return null;
+    }
+}
+/** Reply to a message over direct SMTP with RFC 5322 threading headers. */
+async function sendReplyViaSmtp(id, body, replyAll) {
+    const cfg = resolveSmtpOrFallback();
+    if (!cfg)
+        return { sent: false, fallback: true };
+    const raw = mailManager.getRawSource(id);
+    if (!raw)
+        return { sent: false, fallback: true };
+    const original = parseOriginalHeaders(raw);
+    // Without a Message-ID we can't thread; let Mail.app's reply handle it.
+    if (!original.messageId || original.from.length === 0) {
+        return { sent: false, fallback: true };
+    }
+    const content = mailManager.getMessageContent(id);
+    const opts = buildReplyOptions({
+        original,
+        originalPlainText: content?.plainText ?? "",
+        body,
+        replyAll,
+        self: [cfg.from, cfg.user],
+        from: cfg.from,
+    });
+    const result = await sendViaSmtp(opts, cfg);
+    if (result.success)
+        return { sent: true };
+    return { sent: false, fallback: false, error: result.error ?? "unknown SMTP error" };
+}
+/** Forward a message over direct SMTP (clean MIME, new thread). */
+async function sendForwardViaSmtp(id, to, body) {
+    const cfg = resolveSmtpOrFallback();
+    if (!cfg)
+        return { sent: false, fallback: true };
+    const raw = mailManager.getRawSource(id);
+    if (!raw)
+        return { sent: false, fallback: true };
+    const original = parseOriginalHeaders(raw);
+    const content = mailManager.getMessageContent(id);
+    const opts = buildForwardOptions({
+        original,
+        originalPlainText: content?.plainText ?? "",
+        to,
+        body,
+        from: cfg.from,
+    });
+    const result = await sendViaSmtp(opts, cfg);
+    if (result.success)
+        return { sent: true };
+    return { sent: false, fallback: false, error: result.error ?? "unknown SMTP error" };
+}
 // --- reply-to-message ---
 server.registerTool("reply-to-message", {
     description: "Use when: replying to an existing message by id, preserving its threading headers. Set replyAll for all recipients; set send=false to save as a draft instead of sending.\nReturns: a confirmation that the reply was sent or saved as a draft.\nDo not use when: composing a brand-new message (use send-email / create-draft) or forwarding to new recipients (use forward-message).\nSafety: with the default send=true this SENDS real email immediately and cannot be unsent — require explicit user confirmation of the recipients and body, or pass send=false to let the user review.",
@@ -575,7 +773,19 @@ server.registerTool("reply-to-message", {
         sent: z.boolean().optional(),
         id: z.string().optional(),
     },
-}, withErrorHandling(({ id, body, replyAll, send }) => {
+}, withErrorHandling(async ({ id, body, replyAll, send }) => {
+    // 2.5.0: prefer direct SMTP (clean, correctly threaded MIME) when configured
+    // and actually sending. Drafts (send=false) and the not-configured /
+    // unthreadable cases fall through to the Mail.app AppleScript path.
+    if (send && isSmtpConfigured()) {
+        const outcome = await sendReplyViaSmtp(id, body, replyAll);
+        if (outcome.sent) {
+            return successResponse("Reply sent", { ok: true, sent: true, id });
+        }
+        if (!outcome.fallback) {
+            return errorResponse(`Failed to reply to message "${id}" via SMTP: ${outcome.error}`);
+        }
+    }
     const success = mailManager.replyToMessage(id, body, replyAll, send);
     if (!success) {
         return errorResponse(`Failed to reply to message "${id}"`);
@@ -605,7 +815,22 @@ server.registerTool("forward-message", {
         recipients: z.array(z.string()).optional(),
         id: z.string().optional(),
     },
-}, withErrorHandling(({ id, to, body, send }) => {
+}, withErrorHandling(async ({ id, to, body, send }) => {
+    // 2.5.0: prefer direct SMTP (clean MIME) when configured and actually sending.
+    if (send && isSmtpConfigured()) {
+        const outcome = await sendForwardViaSmtp(id, to, body);
+        if (outcome.sent) {
+            return successResponse(`Message forwarded to ${to.join(", ")}`, {
+                ok: true,
+                sent: true,
+                recipients: to,
+                id,
+            });
+        }
+        if (!outcome.fallback) {
+            return errorResponse(`Failed to forward message "${id}" via SMTP: ${outcome.error}`);
+        }
+    }
     const success = mailManager.forwardMessage(id, to, body, send);
     if (!success) {
         return errorResponse(`Failed to forward message "${id}"`);
@@ -967,21 +1192,65 @@ server.registerTool("list-mailboxes", {
     },
 }, withErrorHandling(async ({ account }) => {
     // IMAP (I6): LIST + per-mailbox STATUS — sees the true server hierarchy and
-    // authoritative counts; falls back to AppleScript for non-IMAP accounts.
-    if (isImapAccount(account)) {
-        const boxes = await imapListMailboxes({ account });
-        const structured = {
-            mailboxes: boxes.map((b) => ({
-                name: b.path,
-                unreadCount: b.unseen,
-                messageCount: b.messages,
-            })),
-            count: boxes.length,
-        };
-        if (boxes.length === 0)
+    // authoritative counts. Prefer-IMAP (v2.6.0):
+    //   - explicit IMAP account → that account's IMAP mailboxes;
+    //   - no account + IMAP configured → concatenate every configured IMAP
+    //     account's mailboxes (each name prefixed with its account label to
+    //     disambiguate identical mailbox names across accounts) PLUS the
+    //     AppleScript mailboxes of every account NOT covered by IMAP.
+    if (shouldUseImap(account)) {
+        if (account !== undefined) {
+            const boxes = await imapListMailboxes({ account });
+            const structured = {
+                mailboxes: boxes.map((b) => ({
+                    name: b.path,
+                    unreadCount: b.unseen,
+                    messageCount: b.messages,
+                })),
+                count: boxes.length,
+            };
+            if (boxes.length === 0)
+                return successResponse("No mailboxes found", structured);
+            const list = boxes.map((b) => `  - ${b.path} (${b.unseen} unread)`).join("\n");
+            return successResponse(`Found ${boxes.length} mailbox(es):\n${list}`, structured);
+        }
+        const configs = resolveImapConfigs();
+        const rows = [];
+        for (const config of configs) {
+            try {
+                const boxes = await imapListMailboxes({ config });
+                for (const b of boxes) {
+                    // Prefix with the account label so "INBOX" from two accounts is
+                    // distinguishable; keep the raw path available via the structured row.
+                    rows.push({
+                        name: `${config.accountLabel}/${b.path}`,
+                        account: config.accountLabel,
+                        unreadCount: b.unseen,
+                        messageCount: b.messages,
+                    });
+                }
+            }
+            catch (e) {
+                console.error(`IMAP list-mailboxes failed for "${config.accountLabel}": ${String(e)}`);
+            }
+        }
+        // AppleScript for the accounts IMAP doesn't cover (no double-listing).
+        const { appleScriptOnly } = partitionAccountsForCounts(mailManager.listAccounts(), configs);
+        for (const acct of appleScriptOnly) {
+            for (const mb of mailManager.listMailboxes(acct.name)) {
+                rows.push({
+                    name: `${acct.name}/${mb.name}`,
+                    account: acct.name,
+                    unreadCount: mb.unreadCount,
+                    messageCount: mb.messageCount,
+                });
+            }
+        }
+        const structured = { mailboxes: rows, count: rows.length };
+        if (rows.length === 0)
             return successResponse("No mailboxes found", structured);
-        const list = boxes.map((b) => `  - ${b.path} (${b.unseen} unread)`).join("\n");
-        return successResponse(`Found ${boxes.length} mailbox(es):\n${list}`, structured);
+        const list = rows.map((b) => `  - ${b.name} (${b.unreadCount} unread)`).join("\n");
+        return successResponse(`Found ${rows.length} mailbox(es):\n${list}`, structured);
     }
     const mailboxes = mailManager.listMailboxes(account);
     const structured = { mailboxes, count: mailboxes.length };
@@ -1005,10 +1274,40 @@ server.registerTool("get-unread-count", {
     },
 }, withErrorHandling(async ({ mailbox, account }) => {
     // IMAP (I4): STATUS (UNSEEN) is authoritative and fast even on huge
-    // mailboxes; falls back to AppleScript for non-IMAP accounts.
-    const count = isImapAccount(account)
-        ? await imapUnreadCount(mailbox, { account })
-        : mailManager.getUnreadCount(mailbox, account);
+    // mailboxes. Prefer-IMAP (v2.6.0). Counts are ACCOUNT-CENTRIC so each account
+    // is counted exactly once even if the coverage heuristic mis-matches:
+    //   - explicit IMAP account → IMAP UNSEEN for that account;
+    //   - no account + IMAP configured → planCountSources assigns each account
+    //     ONE source (its matching IMAP config, else AppleScript) and counts any
+    //     config that matched no account once via IMAP — no double-counting;
+    //   - explicit non-IMAP account (or IMAP unconfigured) → AppleScript.
+    let count;
+    if (shouldUseImap(account)) {
+        if (account !== undefined) {
+            count = await imapUnreadCount(mailbox, { account });
+        }
+        else {
+            const sources = planCountSources(mailManager.listAccounts(), resolveImapConfigs());
+            let total = 0;
+            for (const src of sources) {
+                if (src.kind === "imap") {
+                    try {
+                        total += await imapUnreadCount(mailbox, { config: src.config });
+                    }
+                    catch (e) {
+                        console.error(`IMAP unread-count failed for "${src.label}": ${String(e)}`);
+                    }
+                }
+                else {
+                    total += mailManager.getUnreadCount(mailbox, src.account.name);
+                }
+            }
+            count = total;
+        }
+    }
+    else {
+        count = mailManager.getUnreadCount(mailbox, account);
+    }
     const location = mailbox ? ` in "${mailbox}"` : "";
     return successResponse(`${count} unread message(s)${location}`, {
         unread: count,
@@ -1036,9 +1335,9 @@ server.registerTool("create-mailbox", {
             return errorResponse(r.error || `Failed to create mailbox "${name}"`);
         return successResponse(r.info || `Mailbox "${name}" created`, { ok: true, name });
     }
-    const success = mailManager.createMailbox(name, account);
+    const { success, error } = mailManager.createMailbox(name, account);
     if (!success) {
-        return errorResponse(`Failed to create mailbox "${name}"`);
+        return errorResponse(error || `Failed to create mailbox "${name}"`);
     }
     return successResponse(`Mailbox "${name}" created`, { ok: true, name });
 }, "Error creating mailbox"));
@@ -1447,7 +1746,12 @@ server.registerTool("get-mail-stats", {
 }, withErrorHandling(async ({ account }) => {
     // IMAP (I3): for a named IMAP account, STATUS gives authoritative counts and
     // SEARCH SINCE gives recent activity — fast even on huge mailboxes.
-    if (account && isImapAccount(account)) {
+    //   - explicit IMAP account → IMAP STATUS for that account (today's path);
+    //   - explicit non-IMAP account → AppleScript all-accounts stats below;
+    //   - no account + IMAP configured → MERGE: sum IMAP STATUS over every
+    //     configured account + AppleScript per-account stats for the accounts
+    //     IMAP does NOT cover (partitioned so no account is double-counted).
+    if (account !== undefined && isImapAccount(account)) {
         const s = await imapMailStats({ account });
         const lines = [
             `📊 Mail Statistics — ${account} (IMAP)`,
@@ -1462,6 +1766,77 @@ server.registerTool("get-mail-stats", {
         ];
         return successResponse(lines.join("\n"), { account, ...s });
     }
+    if (account === undefined && shouldUseImap(account)) {
+        let totalMessages = 0;
+        let totalUnread = 0;
+        const recent = { last24h: 0, last7d: 0, last30d: 0 };
+        const perAccount = [];
+        // ACCOUNT-CENTRIC: each account counted via exactly ONE source so a
+        // heuristic mis-match can't double-count. IMAP sources use STATUS; the
+        // AppleScript sources are built from listMailboxes (same source
+        // getMailStats uses) — never getMailStats(), which is all-accounts and
+        // would re-count the IMAP-covered ones. Recently-received from AppleScript
+        // is INBOX-wide (not per-account), so it's omitted for AppleScript sources;
+        // IMAP's per-account recent IS included.
+        const sources = planCountSources(mailManager.listAccounts(), resolveImapConfigs());
+        for (const src of sources) {
+            if (src.kind === "imap") {
+                try {
+                    const s = await imapMailStats({ config: src.config });
+                    totalMessages += s.totalMessages;
+                    totalUnread += s.totalUnread;
+                    recent.last24h += s.recent.last24h;
+                    recent.last7d += s.recent.last7d;
+                    recent.last30d += s.recent.last30d;
+                    perAccount.push({
+                        name: src.label,
+                        totalMessages: s.totalMessages,
+                        unreadMessages: s.totalUnread,
+                        backend: "imap",
+                    });
+                }
+                catch (e) {
+                    console.error(`IMAP mail-stats failed for "${src.label}": ${String(e)}`);
+                }
+            }
+            else {
+                let m = 0;
+                let u = 0;
+                for (const mb of mailManager.listMailboxes(src.account.name)) {
+                    m += mb.messageCount;
+                    u += mb.unreadCount;
+                }
+                totalMessages += m;
+                totalUnread += u;
+                perAccount.push({
+                    name: src.label,
+                    totalMessages: m,
+                    unreadMessages: u,
+                    backend: "applescript",
+                });
+            }
+        }
+        const lines = [
+            `📊 Mail Statistics (merged: IMAP + AppleScript)`,
+            `══════════════════`,
+            `Total messages: ${totalMessages}`,
+            `Unread messages: ${totalUnread}`,
+            ``,
+            `📥 Recently Received (IMAP INBOXes):`,
+            `  Last 24 hours: ${recent.last24h}`,
+            `  Last 7 days: ${recent.last7d}`,
+            `  Last 30 days: ${recent.last30d}`,
+            ``,
+            `📁 By Account:`,
+            ...perAccount.map((a) => `  ${a.name}: ${a.totalMessages} messages (${a.unreadMessages} unread) [${a.backend}]`),
+        ];
+        return successResponse(lines.join("\n"), {
+            totalMessages,
+            totalUnread,
+            accounts: perAccount,
+            recent,
+        });
+    }
     const stats = mailManager.getMailStats();
     const lines = [];
     lines.push(`📊 Mail Statistics`);

package/build/services/appleMailManager.d.ts

@@ -53,7 +53,7 @@ export declare function isPathWithinAllowedRoots(resolvedPath: string): boolean;
  *
  * Exported for unit testing.
  */
-export declare function describeMailboxOpError(op: "delete" | "rename", raw: string): string;
+export declare function describeMailboxOpError(op: "create" | "delete" | "rename", raw: string): string;
 /** Env var to pin the default account (matched by account name or email). */
 export declare const DEFAULT_ACCOUNT_ENV = "APPLE_MAIL_MCP_DEFAULT_ACCOUNT";
 /**
@@ -153,6 +153,38 @@ export declare class AppleMailManager {
      * mailbox structure (create/delete/rename mailbox).
      */
     private invalidateCache;
+    /**
+     * Reads the live `enabled` flag for an account directly from Mail (bypassing
+     * the 60 s account cache) so a guard reflects an account that was enabled or
+     * disabled out-of-band. Returns true/false when known, or null when the probe
+     * is inconclusive — account not found, or the probe itself failed. Callers
+     * treat null as "can't tell, don't block".
+     */
+    private isAccountEnabled;
+    /**
+     * Guard for AppleScript-backed structural operations (create / delete / rename
+     * mailbox). When the target account is disabled in Mail, Mail holds no live
+     * server session for it, so the operation fails inside Mail with an opaque
+     * AppleEvent -10000 — and a multi-step op like rename can leave half-built
+     * state behind (an orphaned destination mailbox). Detect the disabled account
+     * up front and refuse with an actionable message instead of attempting the
+     * doomed op.
+     *
+     * Returns an error string when the account is known-disabled, else null —
+     * including when the state can't be determined. We fail open: an inconclusive
+     * probe never blocks an otherwise-valid operation.
+     *
+     * Applies only to the AppleScript backend. Direct-IMAP accounts talk to the
+     * server independent of Mail's enabled toggle and are routed before reaching
+     * the manager.
+     */
+    private disabledAccountGuard;
+    /**
+     * Best-effort rollback for a failed rename: delete a just-created destination
+     * mailbox, but ONLY if it is empty, so any messages that did move are never
+     * destroyed. Returns true if the empty orphan was removed.
+     */
+    private deleteMailboxIfEmpty;
     /**
      * Resolves the account to use for an operation when the caller omits one.
      *
@@ -479,7 +511,10 @@ export declare class AppleMailManager {
     /**
      * Create a new mailbox.
      */
-    createMailbox(name: string, account?: string): boolean;
+    createMailbox(name: string, account?: string): {
+        success: boolean;
+        error?: string;
+    };
     /**
      * Delete a mailbox.
      */