proton-mail-bridge-client 2.0.8 → 2.1.0

package/dist/index.js

@@ -11,16 +11,10 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, ListResourcesRequestSchema, McpError, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { isMainModule } from "./is-main.js";
 import { AnalyticsService } from "./services/analytics-service.js";
-import { AuditService } from "./services/audit-service.js";
-import { BackgroundSyncService } from "./services/background-sync-service.js";
-import { DeliveryQueueService } from "./services/delivery-queue-service.js";
-import { DraftStoreService } from "./services/draft-store-service.js";
-import { LocalIndexService } from "./services/local-index-service.js";
-import { BULK_ITEM_TIMEOUT_MS, describeImapError, isLikelyAuthenticationError, isLikelyConnectionError, isLikelyTlsMismatchError, SimpleIMAPService, UID_VALIDITY_MISMATCH_ERROR } from "./services/simple-imap-service.js";
-import { applySignature, SMTPService } from "./services/smtp-service.js";
-import { SnoozeService } from "./services/snooze-service.js";
-import { TemplateService } from "./services/template-service.js";
-import { ensureValidEmails, foldQuotedHistory, isTextLikeMimeType, isValidEmail, lowerCaseAddress, normalizeBoolean, normalizeLimit, normalizeJsonValue, parseEmailId, parseEmails, projectFields, renderMarkdown, stringifyForJson, } from "./utils/helpers.js";
+import { BULK_ITEM_TIMEOUT_MS, describeImapError, isLikelyAuthenticationError, isLikelyConnectionError, isLikelyTlsMismatchError, UID_VALIDITY_MISMATCH_ERROR } from "./services/simple-imap-service.js";
+import { applySignature } from "./services/smtp-service.js";
+import { ensureValidEmails, foldQuotedHistory, isTextLikeMimeType, isValidEmail, lowerCaseAddress, normalizeBoolean, normalizeLimit, normalizeJsonValue, parseEmailId, parseEmails, projectFields, renderMarkdown, slugifyAccountAddress, splitAccountPrefix, stringifyForJson, withAccountPrefix, } from "./utils/helpers.js";
+import { AccountManager } from "./services/account-manager.js";
 import { logger } from "./utils/logger.js";
 import { ensureDestructiveConfirmed, ensureEmailActionAllowed, ensureMailboxWriteAllowed, ensureOutboundRecipientsAllowed, ensureRemoteDraftSyncAllowed, ensureSendAllowed, resolveRemoteDraftSync, sanitizeRuntimeConfig, } from "./utils/runtime-policy.js";
 const require = createRequire(import.meta.url);
@@ -59,6 +53,7 @@ const TOOLS = [
                     description: "SMTP priority header.",
                 },
                 fromName: { type: "string", description: "Optional display name for the From header (e.g. 'Alice'). Does not change the sending address." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 sanitizeHtml: { type: "boolean", description: "Strip scripts, event handlers, and remote image beacons from HTML before delivery. Defaults to true when body is HTML.", default: true },
                 replyTo: { type: "string", description: "Optional reply-to email address." },
                 requestReadReceipt: { type: "boolean", description: "Request a read receipt (MDN) via a Disposition-Notification-To header. Most mail clients ask the recipient before honoring it — this is a request, not a guarantee.", default: false },
@@ -142,6 +137,7 @@ const TOOLS = [
             properties: {
                 to: { type: "string", description: "Recipient email address." },
                 customMessage: { type: "string", description: "Optional custom test body." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 confirmed: { type: "boolean", description: "Set to true to confirm this send when PROTONMAIL_CONFIRM_DESTRUCTIVE is enabled." },
             },
             required: ["to"],
@@ -162,6 +158,7 @@ const TOOLS = [
                 cc: { type: "string", description: "Additional CC recipients, comma-separated." },
                 bcc: { type: "string", description: "Additional BCC recipients, comma-separated." },
                 fromName: { type: "string", description: "Optional display name for the From header." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 sanitizeHtml: { type: "boolean", description: "Strip scripts and remote image beacons from HTML before delivery. Defaults to true.", default: true },
                 attachments: {
                     type: "array",
@@ -200,6 +197,7 @@ const TOOLS = [
                 cc: { type: "string", description: "Additional CC recipients, comma-separated." },
                 bcc: { type: "string", description: "Additional BCC recipients, comma-separated." },
                 fromName: { type: "string", description: "Optional display name for the From header." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 sanitizeHtml: { type: "boolean", description: "Strip scripts and remote image beacons from HTML before delivery. Defaults to true.", default: true },
                 attachments: {
                     type: "array",
@@ -239,6 +237,7 @@ const TOOLS = [
                 cc: { type: "string", description: "CC recipients, comma-separated." },
                 bcc: { type: "string", description: "BCC recipients, comma-separated." },
                 fromName: { type: "string", description: "Optional display name for the From header." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 sanitizeHtml: { type: "boolean", description: "Strip scripts and remote image beacons from HTML before delivery. Defaults to true.", default: true },
                 attachments: {
                     type: "array",
@@ -279,6 +278,7 @@ const TOOLS = [
                 isHtml: { type: "boolean", description: "Whether the body should be HTML.", default: false },
                 priority: { type: "string", enum: ["high", "normal", "low"] },
                 replyTo: { type: "string", description: "Optional reply-to email address." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default when the draft is sent (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 notes: { type: "string", description: "Optional local note for the draft." },
                 syncToRemote: {
                     type: "boolean",
@@ -318,6 +318,7 @@ const TOOLS = [
                 cc: { type: "string", description: "Additional CC recipients, comma-separated." },
                 bcc: { type: "string", description: "Additional BCC recipients, comma-separated." },
                 notes: { type: "string", description: "Optional local note for the draft." },
+                from: { type: "string", description: "Store this draft under this address instead of the Bridge login's default (e.g. an additional configured account address). Falls back to the primary account if the address isn't a configured account." },
                 syncToRemote: {
                     type: "boolean",
                     description: "Whether to sync the draft to the Proton Drafts mailbox when IMAP is available.",
@@ -356,6 +357,7 @@ const TOOLS = [
                 cc: { type: "string", description: "CC recipients, comma-separated." },
                 bcc: { type: "string", description: "BCC recipients, comma-separated." },
                 notes: { type: "string", description: "Optional local note for the draft." },
+                from: { type: "string", description: "Store this draft under this address instead of the Bridge login's default (e.g. an additional configured account address). Falls back to the primary account if the address isn't a configured account." },
                 syncToRemote: {
                     type: "boolean",
                     description: "Whether to sync the draft to the Proton Drafts mailbox when IMAP is available.",
@@ -432,6 +434,7 @@ const TOOLS = [
                 isHtml: { type: "boolean", description: "Whether the body should be HTML." },
                 priority: { type: "string", enum: ["high", "normal", "low"] },
                 replyTo: { type: "string", description: "Optional reply-to email address." },
+                from: { type: "string", description: "Send as this address instead of the Bridge login's default when the draft is sent (e.g. an alias or additional address on the same Proton account). Proton accepts any address verified on the account; an address not on the account is rejected by Proton at send time." },
                 notes: { type: "string", description: "Optional local note for the draft." },
                 syncToRemote: {
                     type: "boolean",
@@ -1235,6 +1238,17 @@ const TOOLS = [
         annotations: { readOnlyHint: true },
         inputSchema: { type: "object", properties: {} },
     },
+    {
+        name: "list_accounts",
+        description: "List every configured Proton address (the primary Bridge login plus any additional addresses from PROTONMAIL_ACCOUNTS_JSON), each with its own IMAP/SMTP connection status and local index freshness. Use to see which accounts this server is managing, and each account's `slug` — prefix an emailId/draftId with `<slug>::` to target that account explicitly in any other tool (a plain, unprefixed id always means the primary account). Set checkConnections:true to verify each account's IMAP/SMTP reachability live (slower).",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                checkConnections: { type: "boolean", description: "Verify IMAP/SMTP connectivity for every account (adds a real connection attempt per account).", default: false },
+            },
+        },
+    },
     {
         name: "run_doctor",
         description: "Run a comprehensive production health check covering SMTP auth, IMAP auth, optional IMAP IDLE probe, SQLite index integrity, sync-failed drafts, runtime policy validation, and what this server can/cannot do (capabilities). Also reports this server's own version and entrypoint path — worth checking first when behavior doesn't match the changelog, since an old/orphaned install elsewhere on disk can silently shadow an upgrade and every other field here would still report healthy. Connection failures include a classified diagnosis (authentication_failed vs bridge_unreachable) with a specific fix. Use to fully diagnose or validate the setup. Prefer get_connection_status for a quick protocol-only reachability check.",
@@ -1508,6 +1522,7 @@ const TOOLS = [
                 cc: { type: "string", description: "Additional CC recipients, comma-separated." },
                 bcc: { type: "string", description: "Additional BCC recipients, comma-separated." },
                 notes: { type: "string", description: "Optional local note for the draft." },
+                from: { type: "string", description: "Store this draft under this address instead of the Bridge login's default (e.g. an additional configured account address). Falls back to the primary account if the address isn't a configured account." },
                 syncBefore: {
                     type: "boolean",
                     description: "Refresh the local mailbox index from IMAP before resolving the thread.",
@@ -2128,6 +2143,67 @@ function threadSource(thread) {
         },
     };
 }
+// Recursively prefixes every id-bearing field on a thread (or array of threads) with
+// the owning account's slug via withAccountPrefix, so ids returned by a tool fanned
+// out across accounts (see accountManager.all() usages below) stay globally unique
+// and resolvable back to the right account by splitAccountPrefix. slug is undefined
+// for the primary account, and withAccountPrefix(undefined, id) === id, so the
+// primary's own threads/messages are returned byte-for-byte unchanged — zero
+// behavior change for single-account setups. Deep-clones via JSON round-trip since
+// every field tagged here is plain, already-JSON-serializable data.
+export function tagAccountIds(slug, value) {
+    if (!slug || value === undefined || value === null) {
+        return value;
+    }
+    const clone = JSON.parse(JSON.stringify(value));
+    const prefix = (id) => (typeof id === "string" ? withAccountPrefix(slug, id) : id);
+    const tagThread = (thread) => {
+        if (!thread || typeof thread !== "object") {
+            return;
+        }
+        const t = thread;
+        if (typeof t.id === "string")
+            t.id = prefix(t.id);
+        if (typeof t.latestEmailId === "string")
+            t.latestEmailId = prefix(t.latestEmailId);
+        if (Array.isArray(t.messageIds))
+            t.messageIds = t.messageIds.map(prefix);
+        if (Array.isArray(t.documents)) {
+            for (const doc of t.documents) {
+                if (doc && typeof doc === "object" && typeof doc.emailId === "string") {
+                    doc.emailId = prefix(doc.emailId);
+                }
+            }
+        }
+        if (Array.isArray(t.messages)) {
+            for (const message of t.messages) {
+                if (!message || typeof message !== "object")
+                    continue;
+                const m = message;
+                if (typeof m.id === "string")
+                    m.id = prefix(m.id);
+                if (typeof m.primaryEmailId === "string")
+                    m.primaryEmailId = prefix(m.primaryEmailId);
+                if (typeof m.canonicalId === "string")
+                    m.canonicalId = prefix(m.canonicalId);
+                if (Array.isArray(m.locations)) {
+                    for (const loc of m.locations) {
+                        if (loc && typeof loc === "object" && typeof loc.emailId === "string") {
+                            loc.emailId = prefix(loc.emailId);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    if (Array.isArray(clone)) {
+        clone.forEach(tagThread);
+    }
+    else {
+        tagThread(clone);
+    }
+    return clone;
+}
 // list_drafts has no filter and returns every draft unconditionally — unlike get_draft/create_draft,
 // which each touch exactly one draft the caller already knows the content of. DraftRecord.attachments
 // carries full base64 `content`, and createTextResult() serializes the whole payload TWICE (once into
@@ -2396,6 +2472,109 @@ async function getAnalyticsSampleFromIndex(imapService, localIndexService, days,
     const result = await localIndexService.search({ dateFrom, limit });
     return result.emails;
 }
+// --- Multi-account fan-out helpers (2.2.0) -------------------------------
+//
+// Every helper below is only ever invoked from the ">1 configured account"
+// branch of its call site; the "exactly 1 account" branch always keeps
+// running the original single-bundle code path unchanged, so a
+// single-account setup produces byte-for-byte the same response it always
+// did. These helpers exist purely to keep each case-block's merge logic
+// short and readable.
+function accountSlugForTag(bundle, primarySlug) {
+    return bundle.account.slug === primarySlug ? undefined : bundle.account.slug;
+}
+// Re-sorts a merged, cross-account list of date-bearing items newest-first.
+// Each account's own list already arrives pre-sorted (by relevance, then
+// recency) — this is a reasonable global approximation once several
+// independently-sorted lists are interleaved, not a re-derivation of each
+// service's original relevance score.
+function sortByDateDesc(items, dateOf) {
+    return [...items].sort((left, right) => {
+        const leftTime = new Date(dateOf(left) || 0).getTime();
+        const rightTime = new Date(dateOf(right) || 0).getTime();
+        return rightTime - leftTime;
+    });
+}
+function mergeMailboxLabels(perAccountLabels) {
+    const merged = new Map();
+    for (const labels of perAccountLabels) {
+        for (const label of labels) {
+            const key = `${label.type}:${label.name}`;
+            const existing = merged.get(key);
+            if (existing) {
+                existing.messageCount += label.messageCount;
+                existing.unreadCount += label.unreadCount;
+                existing.threadCount += label.threadCount;
+            }
+            else {
+                merged.set(key, { ...label });
+            }
+        }
+    }
+    return [...merged.values()];
+}
+function mergeContactStats(perAccountContacts, limit) {
+    const merged = new Map();
+    for (const contacts of perAccountContacts) {
+        for (const contact of contacts) {
+            const existing = merged.get(contact.address);
+            if (existing) {
+                existing.incoming += contact.incoming;
+                existing.outgoing += contact.outgoing;
+                existing.totalMessages += contact.totalMessages;
+                if (contact.lastContactAt &&
+                    (!existing.lastContactAt || new Date(contact.lastContactAt).getTime() > new Date(existing.lastContactAt).getTime())) {
+                    existing.lastContactAt = contact.lastContactAt;
+                }
+            }
+            else {
+                merged.set(contact.address, { ...contact });
+            }
+        }
+    }
+    return [...merged.values()]
+        .sort((left, right) => {
+        if (right.totalMessages !== left.totalMessages) {
+            return right.totalMessages - left.totalMessages;
+        }
+        return (right.lastContactAt ?? "").localeCompare(left.lastContactAt ?? "");
+    })
+        .slice(0, limit);
+}
+function mergeCountedEntries(perAccountEntries, keyOf, topN) {
+    const merged = new Map();
+    for (const entries of perAccountEntries) {
+        for (const entry of entries) {
+            const key = keyOf(entry);
+            const existing = merged.get(key);
+            if (existing) {
+                existing.count += entry.count;
+            }
+            else {
+                merged.set(key, { ...entry });
+            }
+        }
+    }
+    return [...merged.values()].sort((left, right) => right.count - left.count).slice(0, topN);
+}
+function mergeVolumeTrends(perAccountTrends) {
+    const merged = new Map();
+    for (const trends of perAccountTrends) {
+        for (const point of trends) {
+            const existing = merged.get(point.date);
+            if (existing) {
+                existing.count += point.count;
+                existing.unreadCount += point.unreadCount;
+                existing.starredCount += point.starredCount;
+                existing.attachmentCount += point.attachmentCount;
+            }
+            else {
+                merged.set(point.date, { ...point });
+            }
+        }
+    }
+    return [...merged.values()].sort((left, right) => left.date.localeCompare(right.date));
+}
 async function runEmailAction(imapService, emailId, action, targetFolder) {
     // undefined for an old-format id (no embedded UIDVALIDITY) — every method
     // below's own assertMailboxUidValidity guard already treats that as
@@ -2540,7 +2719,7 @@ export function ensureBulkBatchSize(uidsLength, max) {
 // call reused for both this and resolveUidsForBulkOp) should pass it, so a
 // stale-generation id gets its own clear error instead of being lumped in
 // with a genuinely malformed one.
-function getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity) {
+export function getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity) {
     if (!emailIds) {
         return [];
     }
@@ -2585,7 +2764,7 @@ function getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity) {
     }
     return excluded;
 }
-function withBulkNotFound(result, excludedEmailIds) {
+export function withBulkNotFound(result, excludedEmailIds) {
     if (excludedEmailIds.length === 0) {
         return result;
     }
@@ -2604,6 +2783,60 @@ function withBulkNotFound(result, excludedEmailIds) {
         ],
     };
 }
+// Groups a bulk/batch tool's emailIds array by the account each id's optional
+// "<slug>::" prefix names (see splitAccountPrefix/resolveAccountForEmailId),
+// so bulk_delete/bulk_move/bulk_update_flags/bulk_update_labels/
+// batch_email_action can run each account's ids against that account's own
+// SimpleIMAPService instance instead of always hitting the primary bundle's
+// shared `imapService`. Map key is the resolved account slug (undefined for
+// the primary account — the same "no prefix" convention as everywhere else),
+// so results can be merged back with each entry's original, possibly
+// prefixed, emailId.
+export function groupEmailIdsByAccount(accountManager, emailIds) {
+    const groups = new Map();
+    for (const emailId of emailIds) {
+        const { accountSlug, rest } = splitAccountPrefix(emailId, accountManager.additionalSlugs());
+        let group = groups.get(accountSlug);
+        if (!group) {
+            group = { bundle: accountManager.bySlugOrPrimary(accountSlug), restIds: [] };
+            groups.set(accountSlug, group);
+        }
+        group.restIds.push(rest);
+    }
+    return groups;
+}
+// Re-applies a group's account-slug prefix to every emailId a BulkOperationResult
+// or notFound entry references — those are built inside SimpleIMAPService (or from
+// the group's own restIds), which knows nothing about account slugs, so the prefix
+// stripped off when grouping (groupEmailIdsByAccount) must be put back before the
+// per-group results are merged into the single response the tool returns.
+export function prefixBulkResult(result, slug) {
+    if (!slug) {
+        return result;
+    }
+    return {
+        ...result,
+        results: result.results.map((entry) => ({ ...entry, emailId: withAccountPrefix(slug, entry.emailId) })),
+    };
+}
+export function prefixNotFound(excluded, slug) {
+    if (!slug) {
+        return excluded;
+    }
+    return excluded.map((entry) => ({ ...entry, emailId: withAccountPrefix(slug, entry.emailId) }));
+}
+// Merges the per-account-group BulkOperationResults produced by the bulk_*
+// handlers into the single combined shape the tool actually returns.
+export function mergeBulkResults(results) {
+    return results.reduce((acc, result) => ({
+        dryRun: acc.dryRun || result.dryRun,
+        total: acc.total + result.total,
+        succeeded: acc.succeeded + result.succeeded,
+        failed: acc.failed + result.failed,
+        notFound: acc.notFound + result.notFound,
+        results: [...acc.results, ...result.results],
+    }), { dryRun: false, total: 0, succeeded: 0, failed: 0, notFound: 0, results: [] });
+}
 function paginateRecentRecords(records, limit, offset) {
     return records.slice(offset, offset + limit);
 }
@@ -2739,6 +2972,78 @@ function isMissingTargetFolderError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /TRYCREATE|NONEXISTENT/i.test(message);
 }
+// PROTONMAIL_ACCOUNTS_JSON: a JSON array of additional Proton addresses on the same
+// account, exposed by Bridge's Split Addresses feature as their own IMAP/SMTP logins.
+// Each entry only needs `address` and `password` — Bridge issues each split address its
+// own Bridge-generated password but keeps the SAME host/ports as the primary connection,
+// and the IMAP/SMTP username for a split address is the address itself. Any of
+// imapHost/imapPort/imapSecure/imapUsername/smtpHost/smtpPort/smtpSecure/smtpUsername may
+// still be overridden explicitly for setups that don't follow that default.
+// Example: [{"address":"me@pm.me","password":"..."},{"address":"me@example.com","password":"...","imapUsername":"me@example.com"}]
+function parseAdditionalAccountsEnv(primary) {
+    const raw = process.env.PROTONMAIL_ACCOUNTS_JSON?.trim();
+    if (!raw) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`PROTONMAIL_ACCOUNTS_JSON is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error("PROTONMAIL_ACCOUNTS_JSON must be a JSON array.");
+    }
+    const seenAddresses = new Set([primary.address.toLowerCase()]);
+    const seenSlugs = new Set([primary.slug]);
+    return parsed.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`PROTONMAIL_ACCOUNTS_JSON[${index}] must be an object.`);
+        }
+        const value = entry;
+        const address = typeof value.address === "string" ? value.address.trim() : "";
+        const password = typeof value.password === "string" ? value.password : "";
+        if (!address || !isValidEmail(address)) {
+            throw new Error(`PROTONMAIL_ACCOUNTS_JSON[${index}].address must be a valid email address.`);
+        }
+        if (!password) {
+            throw new Error(`PROTONMAIL_ACCOUNTS_JSON[${index}].password is required.`);
+        }
+        const lowerAddress = address.toLowerCase();
+        if (seenAddresses.has(lowerAddress)) {
+            throw new Error(`PROTONMAIL_ACCOUNTS_JSON[${index}]: duplicate address "${address}".`);
+        }
+        seenAddresses.add(lowerAddress);
+        const slug = slugifyAccountAddress(address);
+        if (!slug || seenSlugs.has(slug)) {
+            throw new Error(`PROTONMAIL_ACCOUNTS_JSON[${index}]: address "${address}" produces an empty or duplicate account slug ("${slug}").`);
+        }
+        seenSlugs.add(slug);
+        const stringField = (key, fallback) => typeof value[key] === "string" && value[key].trim() ? value[key].trim() : fallback;
+        const numberField = (key, fallback) => typeof value[key] === "number" && Number.isInteger(value[key]) ? value[key] : fallback;
+        const boolField = (key, fallback) => typeof value[key] === "boolean" ? value[key] : fallback;
+        return {
+            address,
+            slug,
+            dataDir: join(primary.dataDir, "accounts", slug),
+            imap: {
+                host: stringField("imapHost", primary.imap.host),
+                port: numberField("imapPort", primary.imap.port),
+                secure: boolField("imapSecure", primary.imap.secure),
+                username: stringField("imapUsername", address),
+                password: stringField("imapPassword", password),
+            },
+            smtp: {
+                host: stringField("smtpHost", primary.smtp.host),
+                port: numberField("smtpPort", primary.smtp.port),
+                secure: boolField("smtpSecure", primary.smtp.secure),
+                username: stringField("smtpUsername", address),
+                password: stringField("smtpPassword", password),
+            },
+        };
+    });
+}
 export function buildConfigFromEnv() {
     const username = readEnvValue("PROTONMAIL_USERNAME");
     const password = readEnvValue("PROTONMAIL_PASSWORD");
@@ -2783,27 +3088,26 @@ export function buildConfigFromEnv() {
     if (isLocalBridgeHost(imapHost)) {
         logger.warn("TLS verification is disabled for local Bridge IMAP connections.", "MCPServer", { host: imapHost });
     }
+    const primarySmtp = { host: smtpHost, port: smtpPort, secure: smtpSecure, username, password };
+    const primaryImap = { host: imapHost, port: imapPort, secure: imapSecure, username: imapUsername, password: imapPassword };
+    const primaryAccount = {
+        address: username,
+        slug: slugifyAccountAddress(username),
+        imap: primaryImap,
+        smtp: primarySmtp,
+        dataDir,
+    };
+    const accounts = [primaryAccount, ...parseAdditionalAccountsEnv(primaryAccount)];
     return {
-        smtp: {
-            host: smtpHost,
-            port: smtpPort,
-            secure: smtpSecure,
-            username,
-            password,
-        },
-        imap: {
-            host: imapHost,
-            port: imapPort,
-            secure: imapSecure,
-            username: imapUsername,
-            password: imapPassword,
-        },
+        smtp: primarySmtp,
+        imap: primaryImap,
         dataDir,
         debug,
         cacheEnabled: true,
         analyticsEnabled: true,
         autoSync,
         syncInterval,
+        accounts,
         runtime: {
             readOnly,
             allowSend,
@@ -2829,34 +3133,96 @@ export function buildConfigFromEnv() {
     };
 }
 export function createServer(config, options = {}) {
-    const smtpService = new SMTPService(config);
-    const imapService = new SimpleIMAPService(config, logger, config.runtime.opDelayMs);
+    // AccountManager builds one full, isolated service stack per configured account
+    // (config.accounts — primary plus any PROTONMAIL_ACCOUNTS_JSON entries). The bare
+    // names below stay bound to the PRIMARY account's stack so every existing
+    // single-account tool handler keeps working completely unchanged; only handlers that
+    // need to act on a specific (possibly non-primary) account resolve through
+    // accountManager instead — see resolveAccountForEmailId/resolveAccountForDraft below.
+    const accountManager = new AccountManager(config, logger);
+    const primaryBundle = accountManager.primary();
+    const smtpService = primaryBundle.smtpService;
+    const imapService = primaryBundle.imapService;
     const analyticsService = new AnalyticsService();
-    const auditService = new AuditService(config);
-    const localIndexService = new LocalIndexService(config, logger);
-    const draftStore = new DraftStoreService(config, logger);
-    const backgroundSyncService = new BackgroundSyncService(config, imapService, localIndexService, logger);
-    const deliveryQueueService = new DeliveryQueueService(config, smtpService, logger);
-    // Lets a fired scheduled_send close the loop back to its source draft —
-    // see DeliveryQueueService.checkDue()'s draftStore usage.
-    deliveryQueueService.setDraftStore(draftStore);
-    const snoozeService = new SnoozeService(config, imapService, logger);
-    const templateService = new TemplateService(config, logger);
+    const auditService = primaryBundle.auditService;
+    const localIndexService = primaryBundle.localIndexService;
+    const draftStore = primaryBundle.draftStore;
+    const backgroundSyncService = primaryBundle.backgroundSyncService;
+    const deliveryQueueService = primaryBundle.deliveryQueueService;
+    const snoozeService = primaryBundle.snoozeService;
+    const templateService = primaryBundle.templateService;
+    // Resolves an emailId's optional account-slug prefix (see splitAccountPrefix) to its
+    // owning AccountBundle, defaulting to the primary account for a plain, unprefixed id —
+    // which covers every id that existed before multi-account support, unchanged.
+    function resolveAccountForEmailId(emailId) {
+        const { accountSlug, rest } = splitAccountPrefix(emailId, accountManager.additionalSlugs());
+        return { bundle: accountManager.bySlugOrPrimary(accountSlug), rest };
+    }
+    // Re-applies a bundle's account-slug prefix to an id that came back bare from that
+    // bundle's own imapService (which only ever understands unprefixed ids) — so a
+    // caller acting on a non-primary account gets back an id that resolveAccountForEmailId
+    // will route to the same account next time. The primary account's ids stay unprefixed,
+    // exactly as before multi-account support existed.
+    function prefixedIdFor(bundle, rawId) {
+        return withAccountPrefix(bundle.account.slug === accountManager.primary().account.slug ? undefined : bundle.account.slug, rawId);
+    }
+    // draftId and emailId share the exact same "<slug>::" prefixing scheme (plain
+    // string-prefix stripping over the non-primary slugs), so draftId resolution reuses
+    // resolveAccountForEmailId itself rather than a second, parallel mechanism.
+    const resolveAccountForDraftId = resolveAccountForEmailId;
+    // The slug to prefix a response id with for this bundle — undefined for the
+    // primary account, so a primary-account id round-trips with NO prefix at all,
+    // exactly as it did before multi-account support existed.
+    function responseSlug(bundle) {
+        return bundle.account.slug === accountManager.primary().account.slug ? undefined : bundle.account.slug;
+    }
+    // Alias for responseSlug — tagAccountIds (added alongside the digest/follow-up
+    // multi-account fan-out) was written against this name; kept as a thin alias rather
+    // than rewriting every call site to the other name.
+    const slugForBundle = responseSlug;
+    // A draft created/updated through a non-primary account's own draftStore needs its
+    // id wrapped with that account's slug prefix in the RESPONSE (so get_draft/
+    // update_draft/send_draft/delete_draft/list_drafts can find it again via
+    // resolveAccountForDraftId) — but every internal draftStore/imapService call for
+    // that account keeps using the bundle's own unprefixed id, exactly as stored on
+    // disk under that account's own dataDir. remoteDraft.emailId is a real emailId (not
+    // a draftId) for a remote copy living in that same account's mailbox, so it gets
+    // the identical prefix treatment for the identical reason.
+    function presentDraft(bundle, draft) {
+        const slug = responseSlug(bundle);
+        if (!slug) {
+            return draft;
+        }
+        return {
+            ...draft,
+            id: withAccountPrefix(slug, draft.id),
+            remoteDraft: draft.remoteDraft?.emailId
+                ? { ...draft.remoteDraft, emailId: withAccountPrefix(slug, draft.remoteDraft.emailId) }
+                : draft.remoteDraft,
+        };
+    }
     if (options.startBackgroundSync) {
-        backgroundSyncService.start();
-        // start()'s first real work is awaiting recoverInterruptedSends(), which
-        // can throw a lock-acquisition-timeout error (see file-lock.ts). Bare
-        // `void` here would turn that into an unhandled rejection, and the
-        // process-wide unhandledRejection handler below calls process.exit(1) —
-        // crashing the whole server before it serves a single request over
-        // nothing worse than startup lock contention. Log and degrade instead:
-        // the delivery queue just won't be running yet.
-        deliveryQueueService.start().catch((error) => {
-            logger.error("deliveryQueueService.start() failed", "MCPServer", error);
-        });
-        // snoozeService.start() is synchronous (returns void, not a Promise) —
-        // nothing to catch here.
-        snoozeService.start();
+        // Every configured account gets its own independent sync/delivery-queue/snooze
+        // loop — additional accounts are not just readable, they stay live-synced exactly
+        // like the primary. The primary's own start() call below is intentionally
+        // redundant with this loop (primaryBundle is included in accountManager.all()) so
+        // this doesn't silently change primary-only behavior if that ever stops holding.
+        for (const bundle of accountManager.all()) {
+            bundle.backgroundSyncService.start();
+            // start()'s first real work is awaiting recoverInterruptedSends(), which
+            // can throw a lock-acquisition-timeout error (see file-lock.ts). Bare
+            // `void` here would turn that into an unhandled rejection, and the
+            // process-wide unhandledRejection handler below calls process.exit(1) —
+            // crashing the whole server before it serves a single request over
+            // nothing worse than startup lock contention. Log and degrade instead:
+            // the delivery queue just won't be running yet.
+            bundle.deliveryQueueService.start().catch((error) => {
+                logger.error("deliveryQueueService.start() failed", "MCPServer", { account: bundle.account.slug, error });
+            });
+            // snoozeService.start() is synchronous (returns void, not a Promise) —
+            // nothing to catch here.
+            bundle.snoozeService.start();
+        }
     }
     const server = new Server({
         name: "proton-mail-bridge-client",
@@ -3006,6 +3372,7 @@ export function createServer(config, options = {}) {
                     const priority = optionalString(args, "priority");
                     const replyTo = optionalString(args, "replyTo");
                     const fromName = optionalString(args, "fromName");
+                    const from = optionalString(args, "from");
                     const sanitizeHtml = normalizeBoolean(args.sanitizeHtml, true);
                     const attachments = optionalAttachmentList(args.attachments);
                     ensureValidEmails(to, "to");
@@ -3014,6 +3381,9 @@ export function createServer(config, options = {}) {
                     if (replyTo && !isValidEmail(replyTo)) {
                         throw new McpError(ErrorCode.InvalidParams, "replyTo must be a valid email address.");
                     }
+                    if (from && !isValidEmail(from)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
                     // dryRun: preview without sending
                     const dryRunSend = normalizeBoolean(args.dryRun, false);
                     // RESTRICT_OUTBOUND_TO_SELF check
@@ -3037,6 +3407,7 @@ export function createServer(config, options = {}) {
                         isHtml,
                         htmlBody,
                         fromName,
+                        from,
                         sanitizeHtml,
                         priority: priority === "high" || priority === "low" || priority === "normal"
                             ? priority
@@ -3059,6 +3430,12 @@ export function createServer(config, options = {}) {
                         undoWindowSeconds = requested;
                     }
                     if (undoWindowSeconds > 0) {
+                        // Scope limitation (follow-up round): the undo-send queue is always the
+                        // primary's deliveryQueueService, so a delayed send with a non-primary
+                        // `from` still only gets the header-override-on-primary fallback at fire
+                        // time, not this account's own SMTP connection — unlike the immediate-send
+                        // path above. Fine for now since `from` is still passed through in the
+                        // payload and Proton accepts any verified address on the account.
                         const sendAt = new Date(Date.now() + undoWindowSeconds * 1000).toISOString();
                         const queued = await withAudit(auditService, name, args, async () => deliveryQueueService.enqueue(emailPayload, sendAt, "undo_send"));
                         return createTextResult({
@@ -3068,12 +3445,22 @@ export function createServer(config, options = {}) {
                             note: `Not sent yet — will send in ~${undoWindowSeconds}s unless canceled with cancel_send. This server must stay running for the send to fire; if it's restarted before sendAt, the send fires on next startup instead.`,
                         });
                     }
-                    const result = await withAudit(auditService, name, args, async () => smtpService.sendEmail(emailPayload));
+                    // A `from` matching a configured additional account routes through that
+                    // account's own SMTP connection — required under Bridge's Split Addresses
+                    // feature, where each address is its own separate IMAP/SMTP login, not just
+                    // an alias on the primary's connection. A `from` that doesn't match any
+                    // configured account falls back to the pre-multi-account behavior: send via
+                    // the primary connection with `from` passed through as a plain header
+                    // override (still valid for a genuine alias only reachable that way).
+                    const sendBundle = from ? accountManager.byAddress(from) : undefined;
+                    const sendSmtp = sendBundle ? sendBundle.smtpService : smtpService;
+                    const sendImap = sendBundle ? sendBundle.imapService : imapService;
+                    const result = await withAudit(auditService, name, args, async () => sendSmtp.sendEmail(emailPayload));
                     let sentCopyTokenSend = "[sent-copy:unverified]";
                     try {
                         const verifyMsgId = result.messageId;
                         if (verifyMsgId) {
-                            const scv = await verifySentCopy(imapService, verifyMsgId);
+                            const scv = await verifySentCopy(sendImap, verifyMsgId);
                             if (scv.found)
                                 sentCopyTokenSend = "[sent-copy:verified]";
                         }
@@ -3098,10 +3485,12 @@ export function createServer(config, options = {}) {
                     return createTextResult(filtered);
                 }
                 case "get_unsubscribe_info": {
-                    const detail = await imapService.getEmailById(requireString(args, "emailId"));
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                    const detail = await bundle.imapService.getEmailById(emailId);
                     const info = extractUnsubscribeInfo(detail);
                     return createTextResult({
-                        emailId: detail.id,
+                        emailId: prefixedIdFor(bundle, detail.id),
                         hasUnsubscribeHeader: Boolean(info.mailto || info.url),
                         mailto: info.mailto,
                         url: info.url,
@@ -3111,7 +3500,9 @@ export function createServer(config, options = {}) {
                     });
                 }
                 case "unsubscribe_sender": {
-                    const detail = await imapService.getEmailById(requireString(args, "emailId"));
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                    const detail = await bundle.imapService.getEmailById(emailId);
                     const info = extractUnsubscribeInfo(detail);
                     if (!info.mailto) {
                         if (info.url) {
@@ -3124,14 +3515,14 @@ export function createServer(config, options = {}) {
                     // info.mailto comes from an untrusted inbound header — subject to the
                     // same outbound restriction as every other send path.
                     ensureOutboundRecipientsAllowed(config.runtime, config.smtp.username, [info.mailto]);
-                    const result = await withAudit(auditService, name, args, () => smtpService.sendEmail({
+                    const result = await withAudit(auditService, name, args, () => bundle.smtpService.sendEmail({
                         to: [info.mailto],
                         subject: "unsubscribe",
                         body: "unsubscribe",
                         isHtml: false,
                     }));
                     return createTextResult({
-                        emailId: detail.id,
+                        emailId: prefixedIdFor(bundle, detail.id),
                         unsubscribedVia: info.mailto,
                         messageId: result.messageId,
                         accepted: result.accepted,
@@ -3143,10 +3534,17 @@ export function createServer(config, options = {}) {
                     if (!isValidEmail(to)) {
                         throw new McpError(ErrorCode.InvalidParams, "to must be a valid email address.");
                     }
+                    const fromTest = optionalString(args, "from");
+                    if (fromTest && !isValidEmail(fromTest)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Send test email to ${to}`);
                     ensureSendAllowed(config.runtime);
                     ensureOutboundRecipientsAllowed(config.runtime, config.smtp.username, [to]);
-                    const result = await withAudit(auditService, name, args, async () => smtpService.sendTestEmail(to, optionalString(args, "customMessage")));
+                    // Same account-routing-or-header-override fallback as send_email.
+                    const testSendBundle = fromTest ? accountManager.byAddress(fromTest) : undefined;
+                    const testSmtp = testSendBundle ? testSendBundle.smtpService : smtpService;
+                    const result = await withAudit(auditService, name, args, async () => testSmtp.sendTestEmail(to, optionalString(args, "customMessage"), testSendBundle ? undefined : fromTest));
                     return createTextResult({
                         messageId: result.messageId,
                         accepted: result.accepted,
@@ -3157,18 +3555,30 @@ export function createServer(config, options = {}) {
                 case "reply_to_email": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Reply to email ${String(args.emailId ?? "?")}`);
                     ensureSendAllowed(config.runtime);
-                    const detail = await imapService.getEmailById(requireString(args, "emailId"));
+                    // The message being replied to might belong to a non-primary account (its
+                    // emailId carries that account's slug prefix) — resolve it the same way
+                    // every other emailId-taking tool does, and read AND send through that same
+                    // account by default (a `from` matching a DIFFERENT configured account still
+                    // wins and routes the send there instead — see sendBundleForReply below).
+                    const { bundle: readBundleReply, rest: emailIdReplyRest } = resolveAccountForEmailId(requireString(args, "emailId"));
+                    const detail = await readBundleReply.imapService.getEmailById(emailIdReplyRest);
                     const markdownBodyReply = optionalString(args, "markdownBody");
                     const body = markdownBodyReply ? markdownBodyReply : requireString(args, "body");
                     const isHtml = markdownBodyReply ? false : normalizeBoolean(args.isHtml, false);
                     const htmlBody = markdownBodyReply ? renderMarkdown(markdownBodyReply).html : undefined;
                     const replyAll = normalizeBoolean(args.replyAll, false);
                     const fromNameReply = optionalString(args, "fromName");
+                    const fromReply = optionalString(args, "from");
+                    if (fromReply && !isValidEmail(fromReply)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
+                    const sendBundleReply = fromReply ? accountManager.byAddress(fromReply) : undefined;
+                    const sendBundleForReply = sendBundleReply ?? readBundleReply;
                     const sanitizeHtmlReply = normalizeBoolean(args.sanitizeHtml, true);
                     const attachments = optionalAttachmentList(args.attachments);
                     const extraCc = parseEmails(optionalString(args, "cc"));
                     const extraBcc = parseEmails(optionalString(args, "bcc"));
-                    const recipients = getReplyRecipients(detail, config.smtp.username, replyAll);
+                    const recipients = getReplyRecipients(detail, readBundleReply.config.smtp.username, replyAll);
                     const cc = uniqueAddresses([...recipients.cc, ...extraCc]);
                     const to = uniqueAddresses(recipients.to);
                     ensureValidEmails(to, "to");
@@ -3192,9 +3602,9 @@ export function createServer(config, options = {}) {
                         }
                     }
                     if (dryRunReply) {
-                        return createTextResult({ dryRun: true, wouldSendTo: { to, cc, bcc: extraBcc }, subject: prefixedSubject(detail.subject, "Re:"), note: "No email was sent." }, false, [emailSource(detail)]);
+                        return createTextResult({ dryRun: true, wouldSendTo: { to, cc, bcc: extraBcc }, subject: prefixedSubject(detail.subject, "Re:"), note: "No email was sent." }, false, [emailSource({ ...detail, id: prefixedIdFor(readBundleReply, detail.id) })]);
                     }
-                    const result = await withAudit(auditService, name, args, async () => smtpService.sendEmail({
+                    const result = await withAudit(auditService, name, args, async () => sendBundleForReply.smtpService.sendEmail({
                         to,
                         cc,
                         bcc: extraBcc,
@@ -3203,6 +3613,7 @@ export function createServer(config, options = {}) {
                         isHtml,
                         htmlBody: signedReply.htmlBody,
                         fromName: fromNameReply,
+                        from: fromReply,
                         sanitizeHtml: sanitizeHtmlReply,
                         inReplyTo: detail.messageId,
                         references: detail.messageId ? [detail.messageId] : undefined,
@@ -3214,14 +3625,14 @@ export function createServer(config, options = {}) {
                     try {
                         const verifyMsgId = result.messageId;
                         if (verifyMsgId) {
-                            const scv = await verifySentCopy(imapService, verifyMsgId);
+                            const scv = await verifySentCopy(sendBundleForReply.imapService, verifyMsgId);
                             if (scv.found)
                                 sentCopyTokenReply = "[sent-copy:verified]";
                         }
                     }
                     catch (_) { }
                     return createTextResult({
-                        repliedTo: detail.id,
+                        repliedTo: prefixedIdFor(readBundleReply, detail.id),
                         to,
                         cc,
                         messageId: result.messageId,
@@ -3229,22 +3640,30 @@ export function createServer(config, options = {}) {
                         rejected: result.rejected,
                         response: result.response,
                         sentCopy: sentCopyTokenReply,
-                    }, false, [emailSource(detail)]);
+                    }, false, [emailSource({ ...detail, id: prefixedIdFor(readBundleReply, detail.id) })]);
                 }
                 case "reply_all_email": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Reply-all to email ${String(args.emailId ?? "?")}`);
                     ensureSendAllowed(config.runtime);
-                    const detailRa = await imapService.getEmailById(requireString(args, "emailId"));
+                    // Same emailId account resolution as reply_to_email — see its comment.
+                    const { bundle: readBundleRa, rest: emailIdRaRest } = resolveAccountForEmailId(requireString(args, "emailId"));
+                    const detailRa = await readBundleRa.imapService.getEmailById(emailIdRaRest);
                     const markdownBodyRa = optionalString(args, "markdownBody");
                     const bodyRa = markdownBodyRa ? markdownBodyRa : requireString(args, "body");
                     const isHtmlRa = markdownBodyRa ? false : normalizeBoolean(args.isHtml, false);
                     const htmlBodyRa = markdownBodyRa ? renderMarkdown(markdownBodyRa).html : undefined;
                     const fromNameRa = optionalString(args, "fromName");
+                    const fromRa = optionalString(args, "from");
+                    if (fromRa && !isValidEmail(fromRa)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
+                    const sendBundleRa = fromRa ? accountManager.byAddress(fromRa) : undefined;
+                    const sendBundleForRa = sendBundleRa ?? readBundleRa;
                     const sanitizeHtmlRa = normalizeBoolean(args.sanitizeHtml, true);
                     const attachmentsRa = optionalAttachmentList(args.attachments);
                     const extraCcRa = parseEmails(optionalString(args, "cc"));
                     const extraBccRa = parseEmails(optionalString(args, "bcc"));
-                    const recipientsRa = getReplyRecipients(detailRa, config.smtp.username, true);
+                    const recipientsRa = getReplyRecipients(detailRa, readBundleRa.config.smtp.username, true);
                     const ccRa = uniqueAddresses([...recipientsRa.cc, ...extraCcRa]);
                     const toRa = uniqueAddresses(recipientsRa.to);
                     ensureValidEmails(toRa, "to");
@@ -3270,7 +3689,7 @@ export function createServer(config, options = {}) {
                     // quoted original — not at the very end, after the quote.
                     const signedReplyRa = applySignature(bodyRa, htmlBodyRa, normalizeBoolean(args.appendSignature, true));
                     const replyBodyRa = includeQuoteRa ? buildReplyText(detailRa, signedReplyRa.body) : signedReplyRa.body;
-                    const resultRa = await withAudit(auditService, name, args, async () => smtpService.sendEmail({
+                    const resultRa = await withAudit(auditService, name, args, async () => sendBundleForRa.smtpService.sendEmail({
                         to: toRa,
                         cc: ccRa,
                         bcc: extraBccRa,
@@ -3279,6 +3698,7 @@ export function createServer(config, options = {}) {
                         isHtml: isHtmlRa,
                         htmlBody: signedReplyRa.htmlBody,
                         fromName: fromNameRa,
+                        from: fromRa,
                         sanitizeHtml: sanitizeHtmlRa,
                         inReplyTo: detailRa.messageId,
                         references: detailRa.messageId ? [detailRa.messageId] : undefined,
@@ -3290,14 +3710,14 @@ export function createServer(config, options = {}) {
                     try {
                         const verifyMsgId = resultRa.messageId;
                         if (verifyMsgId) {
-                            const scv = await verifySentCopy(imapService, verifyMsgId);
+                            const scv = await verifySentCopy(sendBundleForRa.imapService, verifyMsgId);
                             if (scv.found)
                                 sentCopyTokenRa = "[sent-copy:verified]";
                         }
                     }
                     catch (_) { }
                     return createTextResult({
-                        repliedTo: detailRa.id,
+                        repliedTo: prefixedIdFor(readBundleRa, detailRa.id),
                         to: toRa,
                         cc: ccRa,
                         messageId: resultRa.messageId,
@@ -3305,12 +3725,14 @@ export function createServer(config, options = {}) {
                         rejected: resultRa.rejected,
                         response: resultRa.response,
                         sentCopy: sentCopyTokenRa,
-                    }, false, [emailSource(detailRa)]);
+                    }, false, [emailSource({ ...detailRa, id: prefixedIdFor(readBundleRa, detailRa.id) })]);
                 }
                 case "forward_email": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Forward email ${String(args.emailId ?? "?")} to ${String(args.to ?? "?")}`);
                     ensureSendAllowed(config.runtime);
-                    const detail = await imapService.getEmailById(requireString(args, "emailId"));
+                    // Same emailId account resolution as reply_to_email — see its comment.
+                    const { bundle: readBundleFwd, rest: emailIdFwdRest } = resolveAccountForEmailId(requireString(args, "emailId"));
+                    const detail = await readBundleFwd.imapService.getEmailById(emailIdFwdRest);
                     const to = parseEmails(requireString(args, "to"));
                     const cc = parseEmails(optionalString(args, "cc"));
                     const bcc = parseEmails(optionalString(args, "bcc"));
@@ -3319,6 +3741,12 @@ export function createServer(config, options = {}) {
                     const isHtml = markdownBodyFwd ? false : normalizeBoolean(args.isHtml, false);
                     const htmlBody = markdownBodyFwd ? renderMarkdown(markdownBodyFwd).html : undefined;
                     const fromNameFwd = optionalString(args, "fromName");
+                    const fromFwd = optionalString(args, "from");
+                    if (fromFwd && !isValidEmail(fromFwd)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
+                    const sendBundleFwd = fromFwd ? accountManager.byAddress(fromFwd) : undefined;
+                    const sendBundleForFwd = sendBundleFwd ?? readBundleFwd;
                     const sanitizeHtmlFwd = normalizeBoolean(args.sanitizeHtml, true);
                     // args.attachments are new attachments the caller wants to add to the
                     // forward — they are NOT the original message's attachments. Despite
@@ -3361,14 +3789,14 @@ export function createServer(config, options = {}) {
                     const originalAttachments = includeAttachments
                         ? await Promise.all(detail.attachments
                             .filter((a) => a.id && (!attachmentParts || (a.part !== undefined && attachmentParts.includes(a.part))))
-                            .map((a) => imapService.getAttachmentForForward(detail.id, a.id)))
+                            .map((a) => readBundleFwd.imapService.getAttachmentForForward(detail.id, a.id)))
                         : [];
                     const fwdAttachments = [...originalAttachments, ...attachments];
                     // Signature goes right after the user's own note, before the
                     // "---------- Forwarded message ---------" block — not at the very
                     // end, after the forwarded content.
                     const signedFwd = applySignature(body ?? "", htmlBody, normalizeBoolean(args.appendSignature, true));
-                    const result = await withAudit(auditService, name, args, async () => smtpService.sendEmail({
+                    const result = await withAudit(auditService, name, args, async () => sendBundleForFwd.smtpService.sendEmail({
                         to,
                         cc,
                         bcc,
@@ -3377,6 +3805,7 @@ export function createServer(config, options = {}) {
                         isHtml,
                         htmlBody: signedFwd.htmlBody,
                         fromName: fromNameFwd,
+                        from: fromFwd,
                         sanitizeHtml: sanitizeHtmlFwd,
                         attachments: fwdAttachments,
                         // Already applied above, before quote-wrapping.
@@ -3386,14 +3815,14 @@ export function createServer(config, options = {}) {
                     try {
                         const verifyMsgId = result.messageId;
                         if (verifyMsgId) {
-                            const scv = await verifySentCopy(imapService, verifyMsgId);
+                            const scv = await verifySentCopy(sendBundleForFwd.imapService, verifyMsgId);
                             if (scv.found)
                                 sentCopyTokenFwd = "[sent-copy:verified]";
                         }
                     }
                     catch (_) { }
                     return createTextResult({
-                        forwardedMessage: detail.id,
+                        forwardedMessage: prefixedIdFor(readBundleFwd, detail.id),
                         to,
                         cc,
                         messageId: result.messageId,
@@ -3401,7 +3830,7 @@ export function createServer(config, options = {}) {
                         rejected: result.rejected,
                         response: result.response,
                         sentCopy: sentCopyTokenFwd,
-                    }, false, [emailSource(detail)]);
+                    }, false, [emailSource({ ...detail, id: prefixedIdFor(readBundleFwd, detail.id) })]);
                 }
                 case "create_draft": {
                     const to = parseEmails(optionalString(args, "to"));
@@ -3410,6 +3839,7 @@ export function createServer(config, options = {}) {
                     const subject = requireString(args, "subject");
                     const body = requireString(args, "body");
                     const replyTo = optionalString(args, "replyTo");
+                    const from = optionalString(args, "from");
                     const attachments = optionalAttachmentList(args.attachments);
                     const priority = optionalString(args, "priority");
                     ensureValidEmails(to, "to");
@@ -3418,8 +3848,16 @@ export function createServer(config, options = {}) {
                     if (replyTo && !isValidEmail(replyTo)) {
                         throw new McpError(ErrorCode.InvalidParams, "replyTo must be a valid email address.");
                     }
+                    if (from && !isValidEmail(from)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
+                    // A `from` matching a configured additional account stores the draft in
+                    // THAT account's own draftStore (own dataDir/drafts.json) instead of the
+                    // primary's — the draft's id is prefixed with that account's slug in the
+                    // response so get_draft/update_draft/send_draft/... can find it again.
+                    const createDraftBundle = from ? accountManager.byAddress(from) ?? primaryBundle : primaryBundle;
                     const result = await withAudit(auditService, name, args, async () => {
-                        const draft = await draftStore.createDraft({
+                        const draft = await createDraftBundle.draftStore.createDraft({
                             mode: "compose",
                             to,
                             cc,
@@ -3431,12 +3869,13 @@ export function createServer(config, options = {}) {
                                 ? priority
                                 : undefined,
                             replyTo,
+                            from,
                             notes: optionalString(args, "notes"),
                             attachments,
                         });
                         const remoteSyncDecision = resolveRemoteDraftSync(config.runtime, normalizeBoolean(args.syncToRemote, true));
                         const synced = remoteSyncDecision.enabled
-                            ? await syncDraftToRemote(draftStore, smtpService, imapService, draft)
+                            ? await syncDraftToRemote(createDraftBundle.draftStore, createDraftBundle.smtpService, createDraftBundle.imapService, draft)
                             : { draft, remoteSync: undefined };
                         const remoteSync = synced.remoteSync ??
                             (remoteSyncDecision.reason
@@ -3446,7 +3885,7 @@ export function createServer(config, options = {}) {
                                     message: remoteSyncDecision.reason,
                                 }
                                 : undefined);
-                        return remoteSync ? { ...synced.draft, remoteSync } : synced.draft;
+                        return presentDraft(createDraftBundle, remoteSync ? { ...synced.draft, remoteSync } : synced.draft);
                     });
                     return createTextResult(result, false, [
                         draftSource(result),
@@ -3478,8 +3917,12 @@ export function createServer(config, options = {}) {
                     if (to.length === 0) {
                         throw new McpError(ErrorCode.InvalidParams, "Unable to infer reply recipient.");
                     }
+                    // Same from-based draftStore routing as create_draft — see its comment.
+                    const createReplyDraftBundle = optionalString(args, "from") !== undefined
+                        ? accountManager.byAddress(optionalString(args, "from")) ?? primaryBundle
+                        : primaryBundle;
                     const result = await withAudit(auditService, name, args, async () => {
-                        const draft = await draftStore.createDraft({
+                        const draft = await createReplyDraftBundle.draftStore.createDraft({
                             mode: "reply",
                             to,
                             cc,
@@ -3496,7 +3939,7 @@ export function createServer(config, options = {}) {
                         });
                         const remoteSyncDecision = resolveRemoteDraftSync(config.runtime, normalizeBoolean(args.syncToRemote, true));
                         const synced = remoteSyncDecision.enabled
-                            ? await syncDraftToRemote(draftStore, smtpService, imapService, draft)
+                            ? await syncDraftToRemote(createReplyDraftBundle.draftStore, createReplyDraftBundle.smtpService, createReplyDraftBundle.imapService, draft)
                             : { draft, remoteSync: undefined };
                         const remoteSync = synced.remoteSync ??
                             (remoteSyncDecision.reason
@@ -3506,7 +3949,7 @@ export function createServer(config, options = {}) {
                                     message: remoteSyncDecision.reason,
                                 }
                                 : undefined);
-                        return remoteSync ? { ...synced.draft, remoteSync } : synced.draft;
+                        return presentDraft(createReplyDraftBundle, remoteSync ? { ...synced.draft, remoteSync } : synced.draft);
                     });
                     return createTextResult(result, false, [
                         draftSource(result),
@@ -3544,8 +3987,12 @@ export function createServer(config, options = {}) {
                             .map((a) => imapService.getAttachmentForForward(detail.id, a.id)))
                         : [];
                     const attachments = [...originalAttachments, ...callerAttachments];
+                    // Same from-based draftStore routing as create_draft — see its comment.
+                    const createForwardDraftBundle = optionalString(args, "from") !== undefined
+                        ? accountManager.byAddress(optionalString(args, "from")) ?? primaryBundle
+                        : primaryBundle;
                     const result = await withAudit(auditService, name, args, async () => {
-                        const draft = await draftStore.createDraft({
+                        const draft = await createForwardDraftBundle.draftStore.createDraft({
                             mode: "forward",
                             to,
                             cc,
@@ -3560,7 +4007,7 @@ export function createServer(config, options = {}) {
                         });
                         const remoteSyncDecision = resolveRemoteDraftSync(config.runtime, normalizeBoolean(args.syncToRemote, true));
                         const synced = remoteSyncDecision.enabled
-                            ? await syncDraftToRemote(draftStore, smtpService, imapService, draft)
+                            ? await syncDraftToRemote(createForwardDraftBundle.draftStore, createForwardDraftBundle.smtpService, createForwardDraftBundle.imapService, draft)
                             : { draft, remoteSync: undefined };
                         const remoteSync = synced.remoteSync ??
                             (remoteSyncDecision.reason
@@ -3570,7 +4017,7 @@ export function createServer(config, options = {}) {
                                     message: remoteSyncDecision.reason,
                                 }
                                 : undefined);
-                        return remoteSync ? { ...synced.draft, remoteSync } : synced.draft;
+                        return presentDraft(createForwardDraftBundle, remoteSync ? { ...synced.draft, remoteSync } : synced.draft);
                     });
                     return createTextResult(result, false, [
                         draftSource(result),
@@ -3587,6 +4034,9 @@ export function createServer(config, options = {}) {
                     ]);
                 }
                 case "list_drafts": {
+                    // Scope limitation (follow-up round): stays scoped to the primary account's
+                    // drafts only — a non-primary account's drafts aren't listed here yet. Use
+                    // get_draft with that account's prefixed draftId if you already have one.
                     const drafts = await draftStore.listDrafts(normalizeBoolean(args.includeSent, false));
                     return createTextResult({
                         total: drafts.length,
@@ -3594,11 +4044,14 @@ export function createServer(config, options = {}) {
                     }, false, drafts.map(draftSource));
                 }
                 case "list_remote_drafts": {
+                    // Scope limitation (follow-up round): stays scoped to the primary account's
+                    // remote Drafts mailbox only — see list_drafts' identical note.
                     const result = await imapService.listRemoteDrafts(normalizeLimit(args.limit, 50), normalizeLimit(args.offset, 0, 0, 10_000));
                     return createTextResult(result, false, result.emails.map(emailSource));
                 }
                 case "get_draft": {
-                    const draft = await draftStore.getDraft(requireString(args, "draftId"));
+                    const { bundle: getDraftBundle, rest: getDraftIdRest } = resolveAccountForDraftId(requireString(args, "draftId"));
+                    const draft = presentDraft(getDraftBundle, await getDraftBundle.draftStore.getDraft(getDraftIdRest));
                     return createTextResult(draft, false, [
                         draftSource(draft),
                         ...(draft.remoteDraft?.emailId
@@ -3613,11 +4066,12 @@ export function createServer(config, options = {}) {
                     ]);
                 }
                 case "update_draft": {
-                    const draftId = requireString(args, "draftId");
+                    const { bundle: updateDraftBundle, rest: updateDraftIdRest } = resolveAccountForDraftId(requireString(args, "draftId"));
                     const to = args.to === undefined ? undefined : parseEmails(optionalString(args, "to"));
                     const cc = args.cc === undefined ? undefined : parseEmails(optionalString(args, "cc"));
                     const bcc = args.bcc === undefined ? undefined : parseEmails(optionalString(args, "bcc"));
                     const replyTo = optionalString(args, "replyTo");
+                    const from = optionalString(args, "from");
                     const priority = optionalString(args, "priority");
                     const attachments = args.attachments === undefined ? undefined : optionalAttachmentList(args.attachments);
                     if (to) {
@@ -3632,8 +4086,11 @@ export function createServer(config, options = {}) {
                     if (replyTo && !isValidEmail(replyTo)) {
                         throw new McpError(ErrorCode.InvalidParams, "replyTo must be a valid email address.");
                     }
+                    if (from && !isValidEmail(from)) {
+                        throw new McpError(ErrorCode.InvalidParams, "from must be a valid email address.");
+                    }
                     const result = await withAudit(auditService, name, args, async () => {
-                        const draft = await draftStore.updateDraft(draftId, {
+                        const draft = await updateDraftBundle.draftStore.updateDraft(updateDraftIdRest, {
                             to,
                             cc,
                             bcc,
@@ -3644,12 +4101,13 @@ export function createServer(config, options = {}) {
                                 ? priority
                                 : undefined,
                             replyTo,
+                            from,
                             attachments,
                             notes: optionalString(args, "notes"),
                         });
                         const remoteSyncDecision = resolveRemoteDraftSync(config.runtime, normalizeBoolean(args.syncToRemote, true));
                         const synced = remoteSyncDecision.enabled
-                            ? await syncDraftToRemote(draftStore, smtpService, imapService, draft)
+                            ? await syncDraftToRemote(updateDraftBundle.draftStore, updateDraftBundle.smtpService, updateDraftBundle.imapService, draft)
                             : { draft, remoteSync: undefined };
                         const remoteSync = synced.remoteSync ??
                             (remoteSyncDecision.reason
@@ -3659,7 +4117,7 @@ export function createServer(config, options = {}) {
                                     message: remoteSyncDecision.reason,
                                 }
                                 : undefined);
-                        return remoteSync ? { ...synced.draft, remoteSync } : synced.draft;
+                        return presentDraft(updateDraftBundle, remoteSync ? { ...synced.draft, remoteSync } : synced.draft);
                     });
                     return createTextResult(result, false, [
                         draftSource(result),
@@ -3676,16 +4134,18 @@ export function createServer(config, options = {}) {
                 }
                 case "sync_draft_to_remote": {
                     ensureRemoteDraftSyncAllowed(config.runtime);
-                    const draft = await draftStore.getDraft(requireString(args, "draftId"));
-                    const synced = await withAudit(auditService, name, args, async () => syncDraftToRemote(draftStore, smtpService, imapService, draft));
-                    return createTextResult({ ...synced.draft, remoteSync: synced.remoteSync }, false, [
-                        draftSource(synced.draft),
-                        ...(synced.draft.remoteDraft?.emailId
+                    const { bundle: syncDraftBundle, rest: syncDraftIdRest } = resolveAccountForDraftId(requireString(args, "draftId"));
+                    const draft = await syncDraftBundle.draftStore.getDraft(syncDraftIdRest);
+                    const synced = await withAudit(auditService, name, args, async () => syncDraftToRemote(syncDraftBundle.draftStore, syncDraftBundle.smtpService, syncDraftBundle.imapService, draft));
+                    const presentedSynced = presentDraft(syncDraftBundle, synced.draft);
+                    return createTextResult({ ...presentedSynced, remoteSync: synced.remoteSync }, false, [
+                        draftSource(presentedSynced),
+                        ...(presentedSynced.remoteDraft?.emailId
                             ? [
                                 emailSource({
-                                    id: synced.draft.remoteDraft.emailId,
-                                    subject: synced.draft.subject,
-                                    folder: synced.draft.remoteDraft.folder,
+                                    id: presentedSynced.remoteDraft.emailId,
+                                    subject: presentedSynced.subject,
+                                    folder: presentedSynced.remoteDraft.folder,
                                 })
                             ]
                             : []),
@@ -3694,7 +4154,8 @@ export function createServer(config, options = {}) {
                 case "send_draft": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Send draft ${String(args.draftId ?? "?")}`);
                     ensureSendAllowed(config.runtime);
-                    const draft = await draftStore.getDraft(requireString(args, "draftId"));
+                    const { bundle: sendDraftBundle, rest: sendDraftIdRest } = resolveAccountForDraftId(requireString(args, "draftId"));
+                    const draft = await sendDraftBundle.draftStore.getDraft(sendDraftIdRest);
                     // Found live: calling send_draft twice on the same draft sent it
                     // twice — nothing here checked whether it was already marked
                     // "sent" before sending again. Refuse; create_draft for a new
@@ -3707,7 +4168,7 @@ export function createServer(config, options = {}) {
                     // transactions, since nothing here knew about the still-pending
                     // scheduled send. Refuse instead; cancel_send first if the
                     // immediate send is actually what's wanted.
-                    const pendingScheduled = (await deliveryQueueService.list()).find((record) => record.sourceDraftId === draft.id && record.status === "pending");
+                    const pendingScheduled = (await sendDraftBundle.deliveryQueueService.list()).find((record) => record.sourceDraftId === draft.id && record.status === "pending");
                     if (pendingScheduled) {
                         throw new McpError(ErrorCode.InvalidParams, `This draft already has a pending scheduled send (id ${pendingScheduled.id}, sendAt ${pendingScheduled.sendAt}). Sending now would deliver it twice. Cancel that scheduled send with cancel_send first, or wait for it to fire.`);
                     }
@@ -3748,7 +4209,7 @@ export function createServer(config, options = {}) {
                     // them. claimForSending() re-reads status under the draft store's
                     // lock and flips "draft" -> "sending" in that same critical
                     // section — only the call that wins the claim proceeds to SMTP.
-                    await draftStore.claimForSending(draft.id);
+                    await sendDraftBundle.draftStore.claimForSending(draft.id);
                     // Found live: withAudit wrapped the SMTP call, so an audit-log
                     // write failure AFTER a successful send (e.g. disk full) was
                     // indistinguishable from a send failure — it threw out of
@@ -3762,7 +4223,7 @@ export function createServer(config, options = {}) {
                     const sendStartedAt = Date.now();
                     let result;
                     try {
-                        result = await smtpService.sendEmail({
+                        result = await sendDraftBundle.smtpService.sendEmail({
                             to: draft.to,
                             cc: draft.cc,
                             bcc: draft.bcc,
@@ -3771,6 +4232,7 @@ export function createServer(config, options = {}) {
                             isHtml: draft.isHtml,
                             priority: draft.priority,
                             replyTo: draft.replyTo,
+                            from: draft.from,
                             inReplyTo: draft.inReplyTo,
                             references: draft.references,
                             attachments: draft.attachments,
@@ -3785,7 +4247,7 @@ export function createServer(config, options = {}) {
                         // Mirrors SnoozeService.wake()'s catch handler: revert the claim
                         // so the draft is retryable instead of stuck in "sending"
                         // forever because SMTP failed.
-                        await draftStore.revertSending(draft.id);
+                        await sendDraftBundle.draftStore.revertSending(draft.id);
                         await auditService
                             .record({
                             timestamp: new Date().toISOString(),
@@ -3814,14 +4276,14 @@ export function createServer(config, options = {}) {
                     catch (auditError) {
                         logger.error("Failed to record audit log for a successful send_draft — the email was already sent, so the draft is not being reverted", "MCPServer", { draftId: draft.id, error: auditError });
                     }
-                    let sentDraft = await draftStore.markSent(draft.id, {
+                    let sentDraft = await sendDraftBundle.draftStore.markSent(draft.id, {
                         messageId: result.messageId,
                         accepted: result.accepted,
                         rejected: result.rejected,
                         response: result.response,
                     });
                     const remoteCleanup = resolveRemoteDraftSync(config.runtime, true).enabled
-                        ? await clearRemoteDraft(draftStore, imapService, sentDraft)
+                        ? await clearRemoteDraft(sendDraftBundle.draftStore, sendDraftBundle.imapService, sentDraft)
                         : {
                             draft: sentDraft,
                             remoteDelete: sentDraft.remoteDraft?.emailId
@@ -3832,16 +4294,16 @@ export function createServer(config, options = {}) {
                                 }
                                 : undefined,
                         };
-                    sentDraft = remoteCleanup.draft;
+                    sentDraft = presentDraft(sendDraftBundle, remoteCleanup.draft);
                     const sources = [draftSource(sentDraft)];
                     if (sentDraft.sourceEmailId) {
-                        sources.push(emailSource(await imapService.getEmailById(sentDraft.sourceEmailId)));
+                        sources.push(emailSource(await sendDraftBundle.imapService.getEmailById(sentDraft.sourceEmailId)));
                     }
                     let sentCopyTokenDraft = "[sent-copy:unverified]";
                     try {
                         const verifyMsgId = result.messageId;
                         if (verifyMsgId) {
-                            const scv = await verifySentCopy(imapService, verifyMsgId);
+                            const scv = await verifySentCopy(sendDraftBundle.imapService, verifyMsgId);
                             if (scv.found)
                                 sentCopyTokenDraft = "[sent-copy:verified]";
                         }
@@ -3861,7 +4323,8 @@ export function createServer(config, options = {}) {
                 case "schedule_draft": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Schedule draft ${String(args.draftId ?? "?")} to send later`);
                     ensureSendAllowed(config.runtime);
-                    const draft = await draftStore.getDraft(requireString(args, "draftId"));
+                    const { bundle: scheduleDraftBundle, rest: scheduleDraftIdRest } = resolveAccountForDraftId(requireString(args, "draftId"));
+                    const draft = await scheduleDraftBundle.draftStore.getDraft(scheduleDraftIdRest);
                     // Mirrors send_draft's own pendingScheduled guard, for the reverse
                     // ordering: send_draft already delivered this draft once, and
                     // scheduling it again here would deliver it a second time at
@@ -3886,7 +4349,7 @@ export function createServer(config, options = {}) {
                     // duplicate. This external check is kept only as an optional
                     // early-exit optimization to avoid a wasted round-trip to the lock
                     // in the common non-racing case.
-                    const alreadyPendingScheduled = (await deliveryQueueService.list()).find((record) => record.sourceDraftId === draft.id && record.status === "pending");
+                    const alreadyPendingScheduled = (await scheduleDraftBundle.deliveryQueueService.list()).find((record) => record.sourceDraftId === draft.id && record.status === "pending");
                     if (alreadyPendingScheduled) {
                         throw new McpError(ErrorCode.InvalidParams, `This draft already has a pending scheduled send (id ${alreadyPendingScheduled.id}, sendAt ${alreadyPendingScheduled.sendAt}). Scheduling it again would deliver it twice. Cancel the existing one with cancel_send first if you want a different sendAt.`);
                     }
@@ -3912,7 +4375,7 @@ export function createServer(config, options = {}) {
                         if (external.length > 0)
                             throw new McpError(ErrorCode.InvalidParams, "PROTONMAIL_RESTRICT_OUTBOUND_TO_SELF is enabled. All recipients must be the authenticated user.");
                     }
-                    const queued = await withAudit(auditService, name, args, async () => deliveryQueueService.enqueue({
+                    const queued = await withAudit(auditService, name, args, async () => scheduleDraftBundle.deliveryQueueService.enqueue({
                         to: draft.to,
                         cc: draft.cc,
                         bcc: draft.bcc,
@@ -3921,6 +4384,7 @@ export function createServer(config, options = {}) {
                         isHtml: draft.isHtml,
                         priority: draft.priority,
                         replyTo: draft.replyTo,
+                        from: draft.from,
                         inReplyTo: draft.inReplyTo,
                         references: draft.references,
                         attachments: draft.attachments,
@@ -3931,17 +4395,18 @@ export function createServer(config, options = {}) {
                     return createTextResult({
                         queued: true,
                         id: queued.id,
-                        draftId: draft.id,
+                        draftId: withAccountPrefix(responseSlug(scheduleDraftBundle), draft.id),
                         sendAt: queued.sendAt,
                         note: "The draft's content was snapshotted now and queued. This server must stay running for the send to fire at sendAt — if restarted first, it fires on next startup instead. The draft record itself is not automatically marked sent; use cancel_send with this id to abort before it fires.",
                     });
                 }
                 case "delete_draft": {
-                    const draft = await draftStore.getDraft(requireString(args, "draftId"));
+                    const { bundle: deleteDraftBundle, rest: deleteDraftIdRest } = resolveAccountForDraftId(requireString(args, "draftId"));
+                    const draft = await deleteDraftBundle.draftStore.getDraft(deleteDraftIdRest);
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args?.confirmed, false), "Permanently delete draft: " + draft.id);
                     const deleted = await withAudit(auditService, name, args, async () => {
                         const remoteCleanup = resolveRemoteDraftSync(config.runtime, true).enabled
-                            ? await clearRemoteDraft(draftStore, imapService, draft)
+                            ? await clearRemoteDraft(deleteDraftBundle.draftStore, deleteDraftBundle.imapService, draft)
                             : {
                                 draft,
                                 remoteDelete: draft.remoteDraft?.emailId
@@ -3952,8 +4417,10 @@ export function createServer(config, options = {}) {
                                     }
                                     : undefined,
                             };
+                        const deletedResult = await deleteDraftBundle.draftStore.deleteDraft(draft.id);
                         return {
-                            ...(await draftStore.deleteDraft(draft.id)),
+                            ...deletedResult,
+                            id: withAccountPrefix(responseSlug(deleteDraftBundle), deletedResult.id),
                             remoteDelete: remoteCleanup.remoteDelete,
                         };
                     });
@@ -3961,23 +4428,50 @@ export function createServer(config, options = {}) {
                 }
                 case "get_emails": {
                     const effectiveLimit = normalizeLimit(args.limit, 50);
-                    const result = await imapService.getEmails({
+                    const getEmailsInput = {
                         folder: optionalString(args, "folder"),
                         limit: effectiveLimit,
                         offset: typeof args.offset === "number" ? args.offset : undefined,
                         beforeUid: typeof args?.beforeUid === "number" ? args.beforeUid : undefined,
-                        sortByUid: args?.sortByUid === "asc" || args?.sortByUid === "desc" ? args.sortByUid : undefined,
+                        sortByUid: (args?.sortByUid === "asc" || args?.sortByUid === "desc" ? args.sortByUid : undefined),
                         includeSnippet: normalizeBoolean(args.includeSnippet, false),
-                    });
+                    };
+                    if (accountManager.all().length === 1) {
+                        const result = await imapService.getEmails(getEmailsInput);
+                        return createTextResult({
+                            ...result,
+                            emails: projectFields(result.emails, parseFieldsArg(args.fields)),
+                            returned: result.emails.length,
+                            hasMore: result.emails.length === effectiveLimit,
+                        }, false, result.emails.map(emailSource));
+                    }
+                    // Merge strategy: live-fetch each account's own folder page (LIVE IMAP,
+                    // one call per account), tag ids with the account slug, concatenate,
+                    // re-sort newest-first, then re-apply the original limit across the
+                    // merged set (not per account) and sum totals across accounts.
+                    const primarySlug = accountManager.primary().account.slug;
+                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const result = await bundle.imapService.getEmails(getEmailsInput);
+                        return { bundle, result };
+                    }));
+                    const taggedEmails = perAccount.flatMap(({ bundle, result }) => result.emails.map((email) => ({ ...email, id: withAccountPrefix(accountSlugForTag(bundle, primarySlug), email.id) })));
+                    const merged = sortByDateDesc(taggedEmails, (email) => email.internalDate || email.date).slice(0, effectiveLimit);
+                    const total = perAccount.reduce((sum, { result }) => sum + result.total, 0);
                     return createTextResult({
-                        ...result,
-                        emails: projectFields(result.emails, parseFieldsArg(args.fields)),
-                        returned: result.emails.length,
-                        hasMore: result.emails.length === effectiveLimit,
-                    }, false, result.emails.map(emailSource));
+                        folder: getEmailsInput.folder?.trim() || "INBOX",
+                        total,
+                        limit: effectiveLimit,
+                        offset: getEmailsInput.offset ?? 0,
+                        emails: projectFields(merged, parseFieldsArg(args.fields)),
+                        returned: merged.length,
+                        hasMore: merged.length === effectiveLimit,
+                        byAccount: perAccount.map(({ bundle, result }) => ({ slug: bundle.account.slug, total: result.total })),
+                    }, false, merged.map(emailSource));
                 }
                 case "get_email_by_id": {
-                    const detail = await imapService.getEmailById(requireString(args, "emailId"));
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                    const detail = await bundle.imapService.getEmailById(emailId);
                     const preferHtml = normalizeBoolean(args.preferHtml, false);
                     const maxBodyLength = normalizeLimit(args.maxBodyLength, undefined, 1, 500_000);
                     const showHeaders = normalizeBoolean(args.showHeaders, false);
@@ -3988,7 +4482,9 @@ export function createServer(config, options = {}) {
                     // on top without ever removing the always-present full map.
                     if (showHeaders)
                         output.headers = detail.headers;
-                    return createTextResult(output, false, [emailSource(detail), ...detail.attachments.map((attachment) => attachmentSource(detail.id, attachment))]);
+                    const prefixedEmailId = prefixedIdFor(bundle, detail.id);
+                    output.id = prefixedEmailId;
+                    return createTextResult(output, false, [emailSource({ ...detail, id: prefixedEmailId }), ...detail.attachments.map((attachment) => attachmentSource(prefixedEmailId, attachment))]);
                 }
                 case "get_emails_by_ids": {
                     const emailIds = [...new Set(parseStringListArg(args, "emailIds"))];
@@ -4057,7 +4553,8 @@ export function createServer(config, options = {}) {
                 }
                 case "update_message_labels": {
                     ensureMailboxWriteAllowed(config.runtime);
-                    const emailId = requireString(args, "emailId");
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                     const labelsToAdd = Array.isArray(args.labelsToAdd)
                         ? args.labelsToAdd.map(String)
                         : [];
@@ -4072,12 +4569,13 @@ export function createServer(config, options = {}) {
                     // treats that as "unverifiable, don't block on it", same as every
                     // other mutation handler below.
                     const uidValidity = parseEmailId(emailId).uidValidity;
-                    const result = await withAudit(auditService, name, args, async () => imapService.updateMessageLabels(emailId, labelsToAdd, labelsToRemove, uidValidity));
-                    return createTextResult(result, false, [emailSource({ id: emailId })]);
+                    const result = await withAudit(auditService, name, args, async () => bundle.imapService.updateMessageLabels(emailId, labelsToAdd, labelsToRemove, uidValidity));
+                    return createTextResult(result, false, [emailSource({ id: prefixedIdFor(bundle, emailId) })]);
                 }
                 case "update_message_flags": {
                     ensureMailboxWriteAllowed(config.runtime);
-                    const emailId = requireString(args, "emailId");
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                     const flagsToAdd = Array.isArray(args.flagsToAdd)
                         ? args.flagsToAdd.map(String)
                         : [];
@@ -4088,11 +4586,11 @@ export function createServer(config, options = {}) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide at least one flag in flagsToAdd or flagsToRemove.");
                     }
                     const uidValidity = parseEmailId(emailId).uidValidity;
-                    const result = await withAudit(auditService, name, args, async () => imapService.updateMessageFlags(emailId, flagsToAdd, flagsToRemove, uidValidity));
-                    return createTextResult(result, false, [emailSource({ id: emailId })]);
+                    const result = await withAudit(auditService, name, args, async () => bundle.imapService.updateMessageFlags(emailId, flagsToAdd, flagsToRemove, uidValidity));
+                    return createTextResult(result, false, [emailSource({ id: prefixedIdFor(bundle, emailId) })]);
                 }
                 case "count_messages": {
-                    const result = await imapService.countMessages({
+                    const countInput = {
                         folder: optionalString(args, "folder"),
                         query: optionalString(args, "query"),
                         from: optionalString(args, "from"),
@@ -4108,12 +4606,44 @@ export function createServer(config, options = {}) {
                         dateTo: optionalString(args, "dateTo"),
                         sizeLarger: typeof args.sizeLarger === "number" ? args.sizeLarger : undefined,
                         sizeSmaller: typeof args.sizeSmaller === "number" ? args.sizeSmaller : undefined,
+                    };
+                    if (accountManager.all().length === 1) {
+                        const result = await imapService.countMessages(countInput);
+                        return createTextResult(result);
+                    }
+                    // Merge strategy: count in every account's mailbox and sum — folder is
+                    // reported from the request (all accounts are counted against the same
+                    // folder name), with a per-account breakdown alongside the total.
+                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => ({
+                        slug: bundle.account.slug,
+                        ...(await bundle.imapService.countMessages(countInput)),
+                    })));
+                    return createTextResult({
+                        folder: countInput.folder ?? "INBOX",
+                        count: perAccount.reduce((sum, entry) => sum + entry.count, 0),
+                        byAccount: perAccount,
                     });
-                    return createTextResult(result);
                 }
                 case "folder_stats": {
-                    const result = await imapService.getFolderStats(optionalString(args, "folder"), typeof args.scanLimit === "number" ? args.scanLimit : undefined);
-                    return createTextResult(result);
+                    const folderStatsFolder = optionalString(args, "folder");
+                    const scanLimit = typeof args.scanLimit === "number" ? args.scanLimit : undefined;
+                    if (accountManager.all().length === 1) {
+                        const result = await imapService.getFolderStats(folderStatsFolder, scanLimit);
+                        return createTextResult(result);
+                    }
+                    // Merge strategy: fetch stats for the same folder in every account and
+                    // sum the numeric fields (total/unseen); uidNext/uidValidity are
+                    // per-account concepts and only make sense in the breakdown.
+                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => ({
+                        slug: bundle.account.slug,
+                        ...(await bundle.imapService.getFolderStats(folderStatsFolder, scanLimit)),
+                    })));
+                    return createTextResult({
+                        folder: folderStatsFolder ?? "INBOX",
+                        total: perAccount.reduce((sum, entry) => sum + entry.total, 0),
+                        unseen: perAccount.reduce((sum, entry) => sum + entry.unseen, 0),
+                        byAccount: perAccount,
+                    });
                 }
                 case "empty_folder": {
                     if (!config.runtime.allowEmptyFolder) {
@@ -4151,41 +4681,57 @@ export function createServer(config, options = {}) {
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const targetFolder = requireString(args, "targetFolder");
                     const max = getBulkMaxBatchSize(args);
-                    // Only fetched (an extra STATUS round trip) when there are ids to
-                    // check against it — a match-only bulk_move has no ids that could
-                    // be stale, since match resolves directly against the live
-                    // mailbox each time.
-                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
-                    // Resolve the match/emailIds set exactly once and reuse it for both
-                    // the preview and the real run — see resolveUidsForBulkOp's
-                    // comment for why re-resolving `match` a second time (the old
-                    // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    // Also excludes any id whose embedded UIDVALIDITY is stale.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
-                    ensureBulkBatchSize(uids.length, max);
-                    if (normalizeBoolean(args.dryRun, false)) {
-                        const preview = await imapService.bulkMove({
-                            emailIds,
-                            match,
-                            folder,
-                            targetFolder,
-                            resolvedUids: uids,
-                            uidValidity: currentUidValidity,
-                            dryRun: true,
+                    const dryRun = normalizeBoolean(args.dryRun, false);
+                    // emailIds can span multiple configured accounts (a "<slug>::"
+                    // prefix names one; a plain id is the primary's) — group them so
+                    // each account's ids resolve/run against that account's own
+                    // imapService, then merge the per-group results back below. A
+                    // match-only call (no emailIds) has no account identity to group
+                    // by, so it stays scoped to the primary account, unchanged.
+                    const groups = emailIds
+                        ? groupEmailIdsByAccount(accountManager, emailIds)
+                        : new Map([
+                            [undefined, { bundle: primaryBundle, restIds: undefined }],
+                        ]);
+                    let totalUids = 0;
+                    const prepared = [];
+                    for (const [slug, group] of groups) {
+                        // Only fetched (an extra STATUS round trip) when there are ids to
+                        // check against it — a match-only bulk_move has no ids that could
+                        // be stale, since match resolves directly against the live
+                        // mailbox each time.
+                        const currentUidValidity = group.restIds ? await group.bundle.imapService.getMailboxUidValidity(folder) : undefined;
+                        const notFoundEmailIds = getBulkNotFoundEmailIds(group.restIds, folder, currentUidValidity);
+                        // Resolve the match/emailIds set exactly once and reuse it for both
+                        // the preview and the real run — see resolveUidsForBulkOp's
+                        // comment for why re-resolving `match` a second time (the old
+                        // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
+                        // Also excludes any id whose embedded UIDVALIDITY is stale.
+                        const uids = await group.bundle.imapService.resolveUidsForBulkOp(folder, group.restIds, match, currentUidValidity);
+                        totalUids += uids.length;
+                        prepared.push({
+                            slug,
+                            bundle: group.bundle,
+                            notFound: notFoundEmailIds,
+                            run: () => group.bundle.imapService.bulkMove({
+                                emailIds: group.restIds,
+                                match,
+                                folder,
+                                targetFolder,
+                                resolvedUids: uids,
+                                uidValidity: currentUidValidity,
+                                dryRun,
+                            }),
                         });
-                        return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
                     }
-                    const result = await withAudit(auditService, name, args, () => imapService.bulkMove({
-                        emailIds,
-                        match,
-                        folder,
-                        targetFolder,
-                        resolvedUids: uids,
-                        uidValidity: currentUidValidity,
-                        dryRun: false,
-                    }));
-                    return createTextResult(withBulkNotFound(result, notFoundEmailIds));
+                    ensureBulkBatchSize(totalUids, max);
+                    const outputs = [];
+                    for (const group of prepared) {
+                        const outputSlug = group.slug === primaryBundle.account.slug ? undefined : group.slug;
+                        const raw = dryRun ? await group.run() : await withAudit(group.bundle.auditService, name, args, group.run);
+                        outputs.push(withBulkNotFound(prefixBulkResult(raw, outputSlug), prefixNotFound(group.notFound, outputSlug)));
+                    }
+                    return createTextResult(mergeBulkResults(outputs));
                 }
                 case "bulk_delete": {
                     ensureMailboxWriteAllowed(config.runtime);
@@ -4204,45 +4750,60 @@ export function createServer(config, options = {}) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide emailIds OR match, not both.");
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const max = getBulkMaxBatchSize(args);
-                    // Fetched once, up front, and reused for both the notFound
-                    // reporting below and resolveUidsForBulkOp's own filtering — a
-                    // single shared point-in-time value, same "resolve once" spirit
-                    // as the uids resolution itself, so the ids this call reports as
-                    // excluded and the uids it actually acts on can never disagree
-                    // about which generation was current. Only fetched when there are
-                    // ids to check against it (a match-only call has none).
-                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
-                    // Resolve the match/emailIds set exactly once and reuse it for both
-                    // the preview and the real run — see resolveUidsForBulkOp's
-                    // comment for why re-resolving `match` a second time (the old
-                    // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    // Also excludes any id whose embedded UIDVALIDITY is stale — see
-                    // resolveUidsForBulkOp's comment.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
-                    ensureBulkBatchSize(uids.length, max);
-                    if (normalizeBoolean(args.dryRun, false)) {
-                        const preview = await imapService.bulkDelete({
-                            emailIds,
-                            match,
-                            folder,
-                            permanent,
-                            resolvedUids: uids,
-                            uidValidity: currentUidValidity,
-                            dryRun: true,
+                    const dryRun = normalizeBoolean(args.dryRun, false);
+                    // emailIds can span multiple configured accounts — group them so
+                    // each account's ids resolve/run against that account's own
+                    // imapService, then merge the per-group results back below. See
+                    // bulk_move's identical grouping comment. A match-only call stays
+                    // scoped to the primary account, unchanged.
+                    const groups = emailIds
+                        ? groupEmailIdsByAccount(accountManager, emailIds)
+                        : new Map([
+                            [undefined, { bundle: primaryBundle, restIds: undefined }],
+                        ]);
+                    let totalUids = 0;
+                    const prepared = [];
+                    for (const [slug, group] of groups) {
+                        // Fetched once, up front, and reused for both the notFound
+                        // reporting below and resolveUidsForBulkOp's own filtering — a
+                        // single shared point-in-time value, same "resolve once" spirit
+                        // as the uids resolution itself, so the ids this call reports as
+                        // excluded and the uids it actually acts on can never disagree
+                        // about which generation was current. Only fetched when there are
+                        // ids to check against it (a match-only call has none).
+                        const currentUidValidity = group.restIds ? await group.bundle.imapService.getMailboxUidValidity(folder) : undefined;
+                        const notFoundEmailIds = getBulkNotFoundEmailIds(group.restIds, folder, currentUidValidity);
+                        // Resolve the match/emailIds set exactly once and reuse it for both
+                        // the preview and the real run — see resolveUidsForBulkOp's
+                        // comment for why re-resolving `match` a second time (the old
+                        // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
+                        // Also excludes any id whose embedded UIDVALIDITY is stale — see
+                        // resolveUidsForBulkOp's comment.
+                        const uids = await group.bundle.imapService.resolveUidsForBulkOp(folder, group.restIds, match, currentUidValidity);
+                        totalUids += uids.length;
+                        prepared.push({
+                            slug,
+                            bundle: group.bundle,
+                            notFound: notFoundEmailIds,
+                            run: () => group.bundle.imapService.bulkDelete({
+                                emailIds: group.restIds,
+                                match,
+                                folder,
+                                permanent,
+                                resolvedUids: uids,
+                                uidValidity: currentUidValidity,
+                                dryRun,
+                            }),
                         });
-                        return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
                     }
-                    const result = await withAudit(auditService, name, args, () => imapService.bulkDelete({
-                        emailIds,
-                        match,
-                        folder,
-                        permanent,
-                        resolvedUids: uids,
-                        uidValidity: currentUidValidity,
-                        dryRun: false,
-                    }));
-                    return createTextResult(withBulkNotFound(result, notFoundEmailIds));
+                    ensureBulkBatchSize(totalUids, max);
+                    const outputs = [];
+                    for (const group of prepared) {
+                        const outputSlug = group.slug === primaryBundle.account.slug ? undefined : group.slug;
+                        const raw = dryRun ? await group.run() : await withAudit(group.bundle.auditService, name, args, group.run);
+                        outputs.push(withBulkNotFound(prefixBulkResult(raw, outputSlug), prefixNotFound(group.notFound, outputSlug)));
+                    }
+                    return createTextResult(mergeBulkResults(outputs));
                 }
                 case "bulk_update_flags": {
                     ensureMailboxWriteAllowed(config.runtime);
@@ -4262,23 +4823,55 @@ export function createServer(config, options = {}) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide flagsToAdd or flagsToRemove.");
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const max = getBulkMaxBatchSize(args);
-                    // See the bulk_delete case above for why this is fetched once and
-                    // shared between notFound reporting and uid resolution.
-                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
-                    // Resolve the match/emailIds set exactly once and reuse it for both
-                    // the preview and the real run — see resolveUidsForBulkOp's
-                    // comment for why re-resolving `match` a second time (the old
-                    // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    // Also excludes any id whose embedded UIDVALIDITY is stale.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
-                    ensureBulkBatchSize(uids.length, max);
-                    if (normalizeBoolean(args.dryRun, false)) {
-                        const preview = await imapService.bulkUpdateFlags({ emailIds, match, folder, flagsToAdd, flagsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: true });
-                        return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
+                    const dryRun = normalizeBoolean(args.dryRun, false);
+                    // emailIds can span multiple configured accounts — group them so
+                    // each account's ids resolve/run against that account's own
+                    // imapService, then merge the per-group results back below. See
+                    // bulk_move's identical grouping comment. A match-only call stays
+                    // scoped to the primary account, unchanged.
+                    const groups = emailIds
+                        ? groupEmailIdsByAccount(accountManager, emailIds)
+                        : new Map([
+                            [undefined, { bundle: primaryBundle, restIds: undefined }],
+                        ]);
+                    let totalUids = 0;
+                    const prepared = [];
+                    for (const [slug, group] of groups) {
+                        // See the bulk_delete case above for why this is fetched once and
+                        // shared between notFound reporting and uid resolution.
+                        const currentUidValidity = group.restIds ? await group.bundle.imapService.getMailboxUidValidity(folder) : undefined;
+                        const notFoundEmailIds = getBulkNotFoundEmailIds(group.restIds, folder, currentUidValidity);
+                        // Resolve the match/emailIds set exactly once and reuse it for both
+                        // the preview and the real run — see resolveUidsForBulkOp's
+                        // comment for why re-resolving `match` a second time (the old
+                        // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
+                        // Also excludes any id whose embedded UIDVALIDITY is stale.
+                        const uids = await group.bundle.imapService.resolveUidsForBulkOp(folder, group.restIds, match, currentUidValidity);
+                        totalUids += uids.length;
+                        prepared.push({
+                            slug,
+                            bundle: group.bundle,
+                            notFound: notFoundEmailIds,
+                            run: () => group.bundle.imapService.bulkUpdateFlags({
+                                emailIds: group.restIds,
+                                match,
+                                folder,
+                                flagsToAdd,
+                                flagsToRemove,
+                                resolvedUids: uids,
+                                uidValidity: currentUidValidity,
+                                dryRun,
+                            }),
+                        });
                     }
-                    const result = await withAudit(auditService, name, args, () => imapService.bulkUpdateFlags({ emailIds, match, folder, flagsToAdd, flagsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: false }));
-                    return createTextResult(withBulkNotFound(result, notFoundEmailIds));
+                    ensureBulkBatchSize(totalUids, max);
+                    const outputs = [];
+                    for (const group of prepared) {
+                        const outputSlug = group.slug === primaryBundle.account.slug ? undefined : group.slug;
+                        const raw = dryRun ? await group.run() : await withAudit(group.bundle.auditService, name, args, group.run);
+                        outputs.push(withBulkNotFound(prefixBulkResult(raw, outputSlug), prefixNotFound(group.notFound, outputSlug)));
+                    }
+                    return createTextResult(mergeBulkResults(outputs));
                 }
                 case "bulk_update_labels": {
                     ensureMailboxWriteAllowed(config.runtime);
@@ -4296,39 +4889,111 @@ export function createServer(config, options = {}) {
                     const labelsToRemove = Array.isArray(args.labelsToRemove) ? args.labelsToRemove.map(String) : [];
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const max = getBulkMaxBatchSize(args);
-                    // See the bulk_delete case above for why this is fetched once and
-                    // shared between notFound reporting and uid resolution.
-                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
-                    // Resolve the match/emailIds set exactly once and reuse it for both
-                    // the preview and the real run — see resolveUidsForBulkOp's
-                    // comment for why re-resolving `match` a second time (the old
-                    // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    // Also excludes any id whose embedded UIDVALIDITY is stale.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
-                    ensureBulkBatchSize(uids.length, max);
-                    if (normalizeBoolean(args.dryRun, false)) {
-                        const preview = await imapService.bulkUpdateLabels({ emailIds, match, folder, labelsToAdd, labelsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: true });
-                        return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
+                    const dryRun = normalizeBoolean(args.dryRun, false);
+                    // emailIds can span multiple configured accounts — group them so
+                    // each account's ids resolve/run against that account's own
+                    // imapService, then merge the per-group results back below. See
+                    // bulk_move's identical grouping comment. A match-only call stays
+                    // scoped to the primary account, unchanged.
+                    const groups = emailIds
+                        ? groupEmailIdsByAccount(accountManager, emailIds)
+                        : new Map([
+                            [undefined, { bundle: primaryBundle, restIds: undefined }],
+                        ]);
+                    let totalUids = 0;
+                    const prepared = [];
+                    for (const [slug, group] of groups) {
+                        // See the bulk_delete case above for why this is fetched once and
+                        // shared between notFound reporting and uid resolution.
+                        const currentUidValidity = group.restIds ? await group.bundle.imapService.getMailboxUidValidity(folder) : undefined;
+                        const notFoundEmailIds = getBulkNotFoundEmailIds(group.restIds, folder, currentUidValidity);
+                        // Resolve the match/emailIds set exactly once and reuse it for both
+                        // the preview and the real run — see resolveUidsForBulkOp's
+                        // comment for why re-resolving `match` a second time (the old
+                        // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
+                        // Also excludes any id whose embedded UIDVALIDITY is stale.
+                        const uids = await group.bundle.imapService.resolveUidsForBulkOp(folder, group.restIds, match, currentUidValidity);
+                        totalUids += uids.length;
+                        prepared.push({
+                            slug,
+                            bundle: group.bundle,
+                            notFound: notFoundEmailIds,
+                            run: () => group.bundle.imapService.bulkUpdateLabels({
+                                emailIds: group.restIds,
+                                match,
+                                folder,
+                                labelsToAdd,
+                                labelsToRemove,
+                                resolvedUids: uids,
+                                uidValidity: currentUidValidity,
+                                dryRun,
+                            }),
+                        });
+                    }
+                    ensureBulkBatchSize(totalUids, max);
+                    const outputs = [];
+                    for (const group of prepared) {
+                        const outputSlug = group.slug === primaryBundle.account.slug ? undefined : group.slug;
+                        const raw = dryRun ? await group.run() : await withAudit(group.bundle.auditService, name, args, group.run);
+                        outputs.push(withBulkNotFound(prefixBulkResult(raw, outputSlug), prefixNotFound(group.notFound, outputSlug)));
                     }
-                    const result = await withAudit(auditService, name, args, () => imapService.bulkUpdateLabels({ emailIds, match, folder, labelsToAdd, labelsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: false }));
-                    return createTextResult(withBulkNotFound(result, notFoundEmailIds));
+                    return createTextResult(mergeBulkResults(outputs));
                 }
                 case "top_senders": {
-                    const result = await imapService.topSenders({
+                    const topSendersLimit = typeof args.limit === "number" ? args.limit : undefined;
+                    const topSendersInput = {
                         folder: optionalString(args, "folder"),
                         since: optionalString(args, "since"),
                         before: optionalString(args, "before"),
-                        limit: typeof args.limit === "number" ? args.limit : undefined,
+                        limit: topSendersLimit,
                         scanLimit: typeof args.scanLimit === "number" ? args.scanLimit : undefined,
                         excludeSelf: normalizeBoolean(args.excludeSelf, true),
+                    };
+                    if (accountManager.all().length === 1) {
+                        const result = await imapService.topSenders(topSendersInput);
+                        return createTextResult(result);
+                    }
+                    // Merge strategy: scan each account's folder independently, merge
+                    // sender frequency by address (summing counts across accounts), then
+                    // re-sort and re-apply the requested top-N limit over the merged set.
+                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => ({
+                        bundle,
+                        result: await bundle.imapService.topSenders(topSendersInput),
+                    })));
+                    const senderMap = new Map();
+                    for (const { result } of perAccount) {
+                        for (const sender of result.senders) {
+                            const existing = senderMap.get(sender.address);
+                            if (existing) {
+                                existing.count += sender.count;
+                            }
+                            else {
+                                senderMap.set(sender.address, { ...sender });
+                            }
+                        }
+                    }
+                    const mergedSenders = [...senderMap.values()].sort((left, right) => right.count - left.count).slice(0, topSendersLimit ?? 20);
+                    return createTextResult({
+                        folder: topSendersInput.folder?.trim() || "INBOX",
+                        scanned: perAccount.reduce((sum, { result }) => sum + result.scanned, 0),
+                        senders: mergedSenders,
+                        byAccount: perAccount.map(({ bundle, result }) => ({ slug: bundle.account.slug, scanned: result.scanned })),
                     });
-                    return createTextResult(result);
                 }
                 case "move_thread": {
                     ensureMailboxWriteAllowed(config.runtime);
-                    const result = await withAudit(auditService, name, args, () => imapService.moveThread({
-                        messageId: requireString(args, "messageId"),
+                    // A threadId only ever names ONE account — a thread can't span
+                    // multiple mailboxes/accounts — so this reuses
+                    // resolveAccountForEmailId's generic "<slug>::" prefix stripping
+                    // (it doesn't care that the string is an emailId vs a threadId) to
+                    // route the whole call to that account's own imapService/
+                    // auditService. A plain, unprefixed threadId keeps going to the
+                    // primary account, unchanged. Full cross-account thread resolution
+                    // (e.g. a match/threading key that could resolve differently per
+                    // account) is out of scope for this pass.
+                    const { bundle, rest: messageId } = resolveAccountForEmailId(requireString(args, "messageId"));
+                    const result = await withAudit(bundle.auditService, name, args, () => bundle.imapService.moveThread({
+                        messageId,
                         destination: requireString(args, "destination"),
                         acrossFolders: normalizeBoolean(args.acrossFolders, false),
                         dryRun: normalizeBoolean(args.dryRun, false),
@@ -4340,8 +5005,12 @@ export function createServer(config, options = {}) {
                     const permanentThread = normalizeBoolean(args.permanent, false);
                     if (permanentThread)
                         ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), "Permanently delete thread");
-                    const result = await withAudit(auditService, name, args, () => imapService.deleteThread({
-                        messageId: requireString(args, "messageId"),
+                    // See move_thread's comment on scoping by the threadId's own
+                    // "<slug>::" prefix — same convention, same single-account
+                    // limitation.
+                    const { bundle, rest: messageId } = resolveAccountForEmailId(requireString(args, "messageId"));
+                    const result = await withAudit(bundle.auditService, name, args, () => bundle.imapService.deleteThread({
+                        messageId,
                         permanent: permanentThread,
                         acrossFolders: normalizeBoolean(args.acrossFolders, false),
                         dryRun: normalizeBoolean(args.dryRun, false),
@@ -4354,8 +5023,12 @@ export function createServer(config, options = {}) {
                     const flagsToRemove = Array.isArray(args.flagsToRemove) ? args.flagsToRemove.map(String) : [];
                     if (flagsToAdd.length === 0 && flagsToRemove.length === 0)
                         throw new McpError(ErrorCode.InvalidParams, "Provide flagsToAdd or flagsToRemove.");
-                    const result = await withAudit(auditService, name, args, () => imapService.flagThread({
-                        messageId: requireString(args, "messageId"),
+                    // See move_thread's comment on scoping by the threadId's own
+                    // "<slug>::" prefix — same convention, same single-account
+                    // limitation.
+                    const { bundle, rest: messageId } = resolveAccountForEmailId(requireString(args, "messageId"));
+                    const result = await withAudit(bundle.auditService, name, args, () => bundle.imapService.flagThread({
+                        messageId,
                         flagsToAdd,
                         flagsToRemove,
                         acrossFolders: normalizeBoolean(args.acrossFolders, false),
@@ -4395,8 +5068,22 @@ export function createServer(config, options = {}) {
                     const result = await withAudit(auditService, name, args, () => imapService.deleteFolder(labelPath));
                     return createTextResult(result);
                 }
-                case "get_folders":
-                    return createTextResult(await imapService.getFolders());
+                case "get_folders": {
+                    if (accountManager.all().length === 1) {
+                        return createTextResult(await imapService.getFolders());
+                    }
+                    // Merge strategy: fetch each account's own folder list (LIVE IMAP) and
+                    // tag each folder's path with its account slug (except the primary's,
+                    // which is left bare) so the merged list stays unambiguous while a
+                    // single-account setup's own folder paths are completely untouched.
+                    const primarySlug = accountManager.primary().account.slug;
+                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => ({ bundle, folders: await bundle.imapService.getFolders() })));
+                    const merged = perAccount.flatMap(({ bundle, folders }) => folders.map((folder) => {
+                        const slug = accountSlugForTag(bundle, primarySlug);
+                        return slug ? { ...folder, path: `${slug}::${folder.path}`, account: slug } : folder;
+                    }));
+                    return createTextResult(merged);
+                }
                 case "sync_folders":
                     return createTextResult(await imapService.syncFolders());
                 case "create_folder":
@@ -4411,25 +5098,28 @@ export function createServer(config, options = {}) {
                     return createTextResult(await withAudit(auditService, name, args, async () => imapService.deleteFolder(requireString(args, "path"))));
                 case "mark_email_read": {
                     ensureEmailActionAllowed(config.runtime, normalizeBoolean(args.isRead, true) ? "mark_read" : "mark_unread");
-                    const emailId = requireString(args, "emailId");
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                     const uidValidity = parseEmailId(emailId).uidValidity;
-                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.markEmailRead(emailId, normalizeBoolean(args.isRead, true), uidValidity)));
+                    return createTextResult(await withAudit(auditService, name, args, async () => bundle.imapService.markEmailRead(emailId, normalizeBoolean(args.isRead, true), uidValidity)));
                 }
                 case "star_email": {
                     ensureEmailActionAllowed(config.runtime, normalizeBoolean(args.isStarred, true) ? "star" : "unstar");
-                    const emailId = requireString(args, "emailId");
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                     const uidValidity = parseEmailId(emailId).uidValidity;
-                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.starEmail(emailId, normalizeBoolean(args.isStarred, true), uidValidity)));
+                    return createTextResult(await withAudit(auditService, name, args, async () => bundle.imapService.starEmail(emailId, normalizeBoolean(args.isStarred, true), uidValidity)));
                 }
                 case "move_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "move");
-                        const emailId = requireString(args, "emailId");
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                         const targetFolder = requireString(args, "targetFolder");
                         const uidValidity = parseEmailId(emailId).uidValidity;
                         const result = await withAudit(auditService, name, args, async () => {
                             try {
-                                return await imapService.moveEmail(emailId, targetFolder, uidValidity);
+                                return await bundle.imapService.moveEmail(emailId, targetFolder, uidValidity);
                             }
                             catch (error) {
                                 if (isMissingTargetFolderError(error)) {
@@ -4438,75 +5128,82 @@ export function createServer(config, options = {}) {
                                 throw error;
                             }
                         });
-                        const sources = result.targetEmailId
+                        const targetEmailId = result.targetEmailId ? prefixedIdFor(bundle, result.targetEmailId) : undefined;
+                        const sources = targetEmailId
                             ? [
                                 {
-                                    uri: buildEmailResourceUri(result.targetEmailId),
-                                    name: result.targetEmailId,
-                                    title: `Moved email ${result.targetEmailId}`,
+                                    uri: buildEmailResourceUri(targetEmailId),
+                                    name: targetEmailId,
+                                    title: `Moved email ${targetEmailId}`,
                                     description: `${result.targetFolder} · uid ${result.targetUid || result.uid}`,
                                     mimeType: "message/rfc822",
                                 },
                             ]
                             : [];
-                        return createTextResult(result, false, sources);
+                        return createTextResult({ ...result, targetEmailId }, false, sources);
                     }
                 case "archive_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "archive");
-                        const emailId = requireString(args, "emailId");
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                         const uidValidity = parseEmailId(emailId).uidValidity;
-                        const result = await withAudit(auditService, name, args, async () => imapService.archiveEmail(emailId, uidValidity));
-                        const sources = result.targetEmailId
+                        const result = await withAudit(auditService, name, args, async () => bundle.imapService.archiveEmail(emailId, uidValidity));
+                        const targetEmailId = result.targetEmailId ? prefixedIdFor(bundle, result.targetEmailId) : undefined;
+                        const sources = targetEmailId
                             ? [
                                 {
-                                    uri: buildEmailResourceUri(result.targetEmailId),
-                                    name: result.targetEmailId,
-                                    title: `Archived email ${result.targetEmailId}`,
+                                    uri: buildEmailResourceUri(targetEmailId),
+                                    name: targetEmailId,
+                                    title: `Archived email ${targetEmailId}`,
                                     description: `${result.targetFolder} · uid ${result.targetUid || result.uid}`,
                                     mimeType: "message/rfc822",
                                 },
                             ]
                             : [];
-                        return createTextResult(result, false, sources);
+                        return createTextResult({ ...result, targetEmailId }, false, sources);
                     }
                 case "trash_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "trash");
-                        const emailId = requireString(args, "emailId");
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                         const uidValidity = parseEmailId(emailId).uidValidity;
-                        const result = await withAudit(auditService, name, args, async () => imapService.trashEmail(emailId, uidValidity));
-                        const sources = result.targetEmailId
+                        const result = await withAudit(auditService, name, args, async () => bundle.imapService.trashEmail(emailId, uidValidity));
+                        const targetEmailId = result.targetEmailId ? prefixedIdFor(bundle, result.targetEmailId) : undefined;
+                        const sources = targetEmailId
                             ? [
                                 {
-                                    uri: buildEmailResourceUri(result.targetEmailId),
-                                    name: result.targetEmailId,
-                                    title: `Trashed email ${result.targetEmailId}`,
+                                    uri: buildEmailResourceUri(targetEmailId),
+                                    name: targetEmailId,
+                                    title: `Trashed email ${targetEmailId}`,
                                     description: `${result.targetFolder} · uid ${result.targetUid || result.uid}`,
                                     mimeType: "message/rfc822",
                                 },
                             ]
                             : [];
-                        return createTextResult(result, false, sources);
+                        return createTextResult({ ...result, targetEmailId }, false, sources);
                     }
                 case "restore_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "restore");
-                        const emailId = requireString(args, "emailId");
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                         const uidValidity = parseEmailId(emailId).uidValidity;
-                        const result = await withAudit(auditService, name, args, async () => imapService.restoreEmail(emailId, optionalString(args, "targetFolder"), uidValidity));
-                        const sources = result.targetEmailId
+                        const result = await withAudit(auditService, name, args, async () => bundle.imapService.restoreEmail(emailId, optionalString(args, "targetFolder"), uidValidity));
+                        const targetEmailId = result.targetEmailId ? prefixedIdFor(bundle, result.targetEmailId) : undefined;
+                        const sources = targetEmailId
                             ? [
                                 {
-                                    uri: buildEmailResourceUri(result.targetEmailId),
-                                    name: result.targetEmailId,
-                                    title: `Restored email ${result.targetEmailId}`,
+                                    uri: buildEmailResourceUri(targetEmailId),
+                                    name: targetEmailId,
+                                    title: `Restored email ${targetEmailId}`,
                                     description: `${result.targetFolder} · uid ${result.targetUid || result.uid}`,
                                     mimeType: "message/rfc822",
                                 },
                             ]
                             : [];
-                        return createTextResult(result, false, sources);
+                        return createTextResult({ ...result, targetEmailId }, false, sources);
                     }
                 case "snooze_email": {
                     ensureEmailActionAllowed(config.runtime, "archive");
@@ -4570,9 +5267,10 @@ export function createServer(config, options = {}) {
                 case "delete_email": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Permanently delete ${String(args.emailId ?? "?")} (cannot be recovered)`);
                     ensureMailboxWriteAllowed(config.runtime);
-                    const emailId = requireString(args, "emailId");
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                     const uidValidity = parseEmailId(emailId).uidValidity;
-                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.deleteEmail(emailId, uidValidity)));
+                    return createTextResult(await withAudit(auditService, name, args, async () => bundle.imapService.deleteEmail(emailId, uidValidity)));
                 }
                 case "batch_email_action":
                     {
@@ -4589,24 +5287,135 @@ export function createServer(config, options = {}) {
                         if (action === "delete") {
                             ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Permanently delete ${emailIds.length} email(s) (cannot be recovered)`);
                         }
-                        const result = await withAudit(auditService, name, args, async () => applyBatchEmailAction(imapService, [], {
-                            emailIds,
+                        // emailIds can span multiple configured accounts — group them so
+                        // each account's ids run against that account's own imapService
+                        // (and get audited to that account's own auditService), then merge
+                        // the per-group BatchActionResults back into one. continueOnError
+                        // is honored within each group (as before); across groups, a
+                        // failure in one account's group still lets independent, unrelated
+                        // groups for OTHER accounts run — an id in account B failing
+                        // doesn't block account A's ids, which are on an entirely separate
+                        // connection anyway.
+                        const continueOnError = normalizeBoolean(args.continueOnError, true);
+                        const dryRun = normalizeBoolean(args.dryRun, false);
+                        const targetFolder = optionalString(args, "targetFolder");
+                        const groups = groupEmailIdsByAccount(accountManager, emailIds);
+                        const groupResults = [];
+                        for (const [slug, group] of groups) {
+                            const entries = [];
+                            const groupResult = await withAudit(group.bundle.auditService, name, args, () => applyBatchEmailAction(group.bundle.imapService, entries, {
+                                emailIds: group.restIds,
+                                action,
+                                targetFolder,
+                                continueOnError,
+                                dryRun,
+                            }));
+                            groupResults.push({ slug, result: groupResult });
+                        }
+                        const outputSlugFor = (slug) => (slug === primaryBundle.account.slug ? undefined : slug);
+                        const mergedResults = groupResults.flatMap(({ slug, result: groupResult }) => groupResult.results.map((entry) => ({ ...entry, emailId: withAccountPrefix(outputSlugFor(slug), entry.emailId) })));
+                        // Reordered to match the caller's original emailIds order (each
+                        // group only preserves order within itself) so a mixed-account
+                        // request's results still line up with the ids the caller passed.
+                        const byEmailId = new Map(mergedResults.map((entry) => [entry.emailId, entry]));
+                        const orderedResults = emailIds.flatMap((emailId) => {
+                            const entry = byEmailId.get(emailId);
+                            return entry ? [entry] : [];
+                        });
+                        const succeeded = orderedResults.filter((entry) => entry.ok).length;
+                        const result = {
                             action,
-                            targetFolder: optionalString(args, "targetFolder"),
-                            continueOnError: normalizeBoolean(args.continueOnError, true),
-                            dryRun: normalizeBoolean(args.dryRun, false),
-                        }));
+                            total: orderedResults.length,
+                            succeeded,
+                            failed: orderedResults.length - succeeded,
+                            results: orderedResults,
+                        };
                         const sources = result.results.flatMap((entry) => entry.ok ? emailSourceFromActionResult(entry.result) : []);
                         return createTextResult(result, false, sources);
                     }
                 case "get_email_stats": {
-                    const folders = await imapService.getFolders();
-                    const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, typeof args.days === "number" ? args.days : 30, typeof args.limit === "number" ? args.limit : 2000);
-                    return createTextResult(analyticsService.getEmailStats(sample, folders, config.smtp.username));
+                    const statsDays = typeof args.days === "number" ? args.days : 30;
+                    const statsLimit = typeof args.limit === "number" ? args.limit : 2000;
+                    if (accountManager.all().length === 1) {
+                        const folders = await imapService.getFolders();
+                        const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, statsDays, statsLimit);
+                        return createTextResult(analyticsService.getEmailStats(sample, folders, config.smtp.username));
+                    }
+                    // Merge strategy: compute each account's own stats independently
+                    // (self-detection needs each account's own address), then sum the
+                    // numeric mailbox/sample fields and merge folder lists (non-primary
+                    // folder paths tagged with their account slug to avoid collisions).
+                    const primarySlugForStats = accountManager.primary().account.slug;
+                    const statsPerAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const folders = await bundle.imapService.getFolders();
+                        const sample = await getAnalyticsSampleFromIndex(bundle.imapService, bundle.localIndexService, statsDays, statsLimit);
+                        return {
+                            bundle,
+                            stats: analyticsService.getEmailStats(sample, folders, bundle.config.smtp.username),
+                        };
+                    }));
+                    return createTextResult({
+                        generatedAt: new Date().toISOString(),
+                        mailbox: {
+                            folderCount: statsPerAccount.reduce((sum, { stats }) => sum + stats.mailbox.folderCount, 0),
+                            totalMessages: statsPerAccount.reduce((sum, { stats }) => sum + stats.mailbox.totalMessages, 0),
+                            unreadMessages: statsPerAccount.reduce((sum, { stats }) => sum + stats.mailbox.unreadMessages, 0),
+                        },
+                        sample: {
+                            size: statsPerAccount.reduce((sum, { stats }) => sum + stats.sample.size, 0),
+                            starredMessages: statsPerAccount.reduce((sum, { stats }) => sum + stats.sample.starredMessages, 0),
+                            messagesWithAttachments: statsPerAccount.reduce((sum, { stats }) => sum + stats.sample.messagesWithAttachments, 0),
+                            uniqueContacts: statsPerAccount.reduce((sum, { stats }) => sum + stats.sample.uniqueContacts, 0),
+                        },
+                        folders: statsPerAccount.flatMap(({ bundle, stats }) => {
+                            const slug = accountSlugForTag(bundle, primarySlugForStats);
+                            return stats.folders.map((folder) => (slug ? { ...folder, path: `${slug}::${folder.path}` } : folder));
+                        }),
+                        byAccount: statsPerAccount.map(({ bundle, stats }) => ({ slug: bundle.account.slug, mailbox: stats.mailbox, sample: stats.sample })),
+                    });
                 }
                 case "get_email_analytics": {
-                    const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, typeof args.days === "number" ? args.days : 30, typeof args.limit === "number" ? args.limit : 2000);
-                    return createTextResult(analyticsService.getEmailAnalytics(sample, config.smtp.username));
+                    const analyticsDays = typeof args.days === "number" ? args.days : 30;
+                    const analyticsLimit = typeof args.limit === "number" ? args.limit : 2000;
+                    if (accountManager.all().length === 1) {
+                        const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, analyticsDays, analyticsLimit);
+                        return createTextResult(analyticsService.getEmailAnalytics(sample, config.smtp.username));
+                    }
+                    // Merge strategy: compute each account's own analytics independently
+                    // (self-detection needs each account's own address), then merge the
+                    // top-N breakdowns (hours/senders/domains) by summing counts per key
+                    // and re-sorting, and recompute busiestDay/insights from the merged
+                    // results.
+                    const analyticsPerAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const sample = await getAnalyticsSampleFromIndex(bundle.imapService, bundle.localIndexService, analyticsDays, analyticsLimit);
+                        return analyticsService.getEmailAnalytics(sample, bundle.config.smtp.username);
+                    }));
+                    const busiestHours = mergeCountedEntries(analyticsPerAccount.map((entry) => entry.busiestHours), (entry) => entry.hour, 5);
+                    const topSenders = mergeCountedEntries(analyticsPerAccount.map((entry) => entry.topSenders), (entry) => entry.address, 10);
+                    const topDomains = mergeCountedEntries(analyticsPerAccount.map((entry) => entry.topDomains), (entry) => entry.domain, 10);
+                    const busiestDayCandidates = analyticsPerAccount.flatMap((entry) => (entry.busiestDay ? [entry.busiestDay] : []));
+                    const busiestDay = busiestDayCandidates.length > 0
+                        ? busiestDayCandidates.reduce((best, candidate) => (candidate.count > best.count ? candidate : best))
+                        : undefined;
+                    return createTextResult({
+                        generatedAt: new Date().toISOString(),
+                        sampleSize: analyticsPerAccount.reduce((sum, entry) => sum + entry.sampleSize, 0),
+                        busiestHours,
+                        topSenders,
+                        topDomains,
+                        busiestDay,
+                        insights: [
+                            busiestHours[0]
+                                ? `Peak sampled activity occurs around ${busiestHours[0].hour}.`
+                                : "No recent activity was available for hourly analysis.",
+                            topSenders[0]
+                                ? `Top sender in the sampled window: ${topSenders[0].address}.`
+                                : "No sender data was available in the sampled window.",
+                            busiestDay
+                                ? `Busiest sampled day was ${busiestDay.date} with ${busiestDay.count} messages.`
+                                : "No day-level trend data was available.",
+                        ],
+                    });
                 }
                 case "get_contacts": {
                     // limit is "how many contacts to return", not "how many messages to
@@ -4615,13 +5424,35 @@ export function createServer(config, options = {}) {
                     // get_contacts returns a ranked list. Reusing limit as the sample size
                     // meant limit: 5 silently ranked contacts from only 5 messages total.
                     const limit = normalizeLimit(args.limit, 100);
-                    const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, 30, 3000);
-                    return createTextResult(analyticsService.getContacts(sample, limit, config.smtp.username));
+                    if (accountManager.all().length === 1) {
+                        const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, 30, 3000);
+                        return createTextResult(analyticsService.getContacts(sample, limit, config.smtp.username));
+                    }
+                    // Merge strategy: compute each account's own contact list independently
+                    // (self-detection needs each account's own address), then merge same
+                    // address across accounts by summing incoming/outgoing/totalMessages
+                    // and keeping the most recent lastContactAt, and re-apply the
+                    // requested limit over the merged, re-sorted set.
+                    const contactsPerAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const sample = await getAnalyticsSampleFromIndex(bundle.imapService, bundle.localIndexService, 30, 3000);
+                        return analyticsService.getContacts(sample, Number.MAX_SAFE_INTEGER, bundle.config.smtp.username);
+                    }));
+                    return createTextResult(mergeContactStats(contactsPerAccount, limit));
                 }
                 case "get_volume_trends": {
                     const days = normalizeLimit(args.days, 30, 1, 365);
-                    const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, days, 3000);
-                    return createTextResult(analyticsService.getVolumeTrends(sample, days));
+                    if (accountManager.all().length === 1) {
+                        const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, days, 3000);
+                        return createTextResult(analyticsService.getVolumeTrends(sample, days));
+                    }
+                    // Merge strategy: compute each account's own daily trend points
+                    // independently, then sum count/unreadCount/starredCount/attachmentCount
+                    // for matching dates across accounts.
+                    const trendsPerAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const sample = await getAnalyticsSampleFromIndex(bundle.imapService, bundle.localIndexService, days, 3000);
+                        return analyticsService.getVolumeTrends(sample, days);
+                    }));
+                    return createTextResult(mergeVolumeTrends(trendsPerAccount));
                 }
                 case "get_connection_status": {
                     const includeRawConnectionErrors = process.env.PROTONMAIL_DEBUG === "true";
@@ -4723,6 +5554,36 @@ export function createServer(config, options = {}) {
                         }
                         return undefined;
                     };
+                    // Per-account breakdown, purely additive alongside every existing top-level
+                    // field above (which keep describing the PRIMARY account only, unchanged, for
+                    // backward compatibility) — same shape list_accounts already returns, plus a
+                    // live connection check reusing that same checkConnections pattern, gated on
+                    // this tool's own includeSmtp/includeImap flags.
+                    const accountsInfo = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const [accountIndexStatus, connection] = await Promise.all([
+                            bundle.localIndexService.getStatus(),
+                            includeSmtp || includeImap
+                                ? Promise.allSettled([
+                                    includeSmtp ? bundle.smtpService.verifyConnection() : Promise.resolve(undefined),
+                                    includeImap ? bundle.imapService.ping() : Promise.resolve(undefined),
+                                ]).then(([smtpResult, imapResult]) => ({
+                                    smtp: !includeSmtp
+                                        ? undefined
+                                        : smtpResult.status === "fulfilled" ? { ok: true } : { ok: false, error: describeImapError(smtpResult.reason) },
+                                    imap: !includeImap
+                                        ? undefined
+                                        : imapResult.status === "fulfilled" ? { ok: true } : { ok: false, error: describeImapError(imapResult.reason) },
+                                }))
+                                : Promise.resolve(undefined),
+                        ]);
+                        return {
+                            slug: bundle.account.slug,
+                            address: bundle.account.address,
+                            isPrimary: bundle.account.slug === primaryBundle.account.slug,
+                            index: { storedMessageCount: accountIndexStatus.storedMessageCount, updatedAt: accountIndexStatus.updatedAt, isStale: accountIndexStatus.isStale },
+                            connection,
+                        };
+                    }));
                     return createTextResult({
                         checkedAt: new Date().toISOString(),
                         // See get_connection_status for why this matters: from inside
@@ -4798,6 +5659,7 @@ export function createServer(config, options = {}) {
                                 "vacation responder (Proton account API only, not exposed via Bridge)",
                             ],
                         },
+                        accounts: accountsInfo,
                     });
                 }
                 case "get_runtime_status": {
@@ -4805,6 +5667,20 @@ export function createServer(config, options = {}) {
                         localIndexService.getStatus(),
                         draftStore.listDrafts(true),
                     ]);
+                    // Per-account breakdown, purely additive alongside every existing top-level
+                    // field above (which keep describing the PRIMARY account only, unchanged, for
+                    // backward compatibility) — same shape list_accounts already returns, index
+                    // status only (no live connection check here — this tool is meant to be fast,
+                    // unlike run_doctor).
+                    const accountsInfo = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const accountIndexStatus = await bundle.localIndexService.getStatus();
+                        return {
+                            slug: bundle.account.slug,
+                            address: bundle.account.address,
+                            isPrimary: bundle.account.slug === primaryBundle.account.slug,
+                            index: { storedMessageCount: accountIndexStatus.storedMessageCount, updatedAt: accountIndexStatus.updatedAt, isStale: accountIndexStatus.isStale },
+                        };
+                    }));
                     return createTextResult({
                         checkedAt: new Date().toISOString(),
                         runtime: sanitizeRuntimeConfig(config.runtime),
@@ -4820,6 +5696,37 @@ export function createServer(config, options = {}) {
                             remoteSynced: drafts.filter((draft) => draft.remoteSyncState === "synced").length,
                             syncFailed: drafts.filter((draft) => draft.remoteSyncState === "sync_failed").length,
                         },
+                        accounts: accountsInfo,
+                    });
+                }
+                case "list_accounts": {
+                    const checkConnections = normalizeBoolean(args.checkConnections, false);
+                    const accountsInfo = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const [indexStatus, connection] = await Promise.all([
+                            bundle.localIndexService.getStatus(),
+                            checkConnections
+                                ? Promise.allSettled([bundle.smtpService.verifyConnection(), bundle.imapService.ping()]).then(([smtpResult, imapResult]) => ({
+                                    smtp: smtpResult.status === "fulfilled" ? { ok: true } : { ok: false, error: describeImapError(smtpResult.reason) },
+                                    imap: imapResult.status === "fulfilled" ? { ok: true } : { ok: false, error: describeImapError(imapResult.reason) },
+                                }))
+                                : Promise.resolve(undefined),
+                        ]);
+                        return {
+                            slug: bundle.account.slug,
+                            address: bundle.account.address,
+                            isPrimary: bundle.account.slug === accountManager.primary().account.slug,
+                            imapUsername: bundle.account.imap.username,
+                            smtpUsername: bundle.account.smtp.username,
+                            dataDir: bundle.account.dataDir,
+                            index: { storedMessageCount: indexStatus.storedMessageCount, updatedAt: indexStatus.updatedAt, isStale: indexStatus.isStale },
+                            connection,
+                        };
+                    }));
+                    return createTextResult({
+                        checkedAt: new Date().toISOString(),
+                        total: accountsInfo.length,
+                        accounts: accountsInfo,
+                        note: "Prefix an emailId/draftId with '<slug>::' to target a non-primary account in any other tool; a plain id always means the primary account.",
                     });
                 }
                 case "run_background_sync":
@@ -4893,7 +5800,7 @@ export function createServer(config, options = {}) {
                     return createTextResult(await localIndexService.getStatus());
                 case "search_indexed_emails":
                     {
-                        const result = await localIndexService.search({
+                        const searchIndexedInput = {
                             query: optionalString(args, "query"),
                             folder: optionalString(args, "folder"),
                             label: optionalString(args, "label"),
@@ -4910,133 +5817,346 @@ export function createServer(config, options = {}) {
                             dateFrom: optionalString(args, "dateFrom"),
                             dateTo: optionalString(args, "dateTo"),
                             limit: typeof args.limit === "number" ? args.limit : undefined,
-                        });
-                        return createTextResult({ ...result, emails: projectFields(result.emails, parseFieldsArg(args.fields)) }, false, result.emails.map(emailSource));
+                        };
+                        if (accountManager.all().length === 1) {
+                            const result = await localIndexService.search(searchIndexedInput);
+                            return createTextResult({ ...result, emails: projectFields(result.emails, parseFieldsArg(args.fields)) }, false, result.emails.map(emailSource));
+                        }
+                        // Merge strategy: search every account's local index independently,
+                        // tag ids with the account slug, concatenate, re-sort newest-first
+                        // (each account's own list already arrives relevance-sorted, so this
+                        // is an approximation of a single global ranking), then re-apply the
+                        // requested limit across the merged set and sum totals/hasMore.
+                        const primarySlugForSearch = accountManager.primary().account.slug;
+                        const searchPerAccount = await Promise.all(accountManager.all().map(async (bundle) => ({ bundle, result: await bundle.localIndexService.search(searchIndexedInput) })));
+                        const searchLimit = searchIndexedInput.limit ?? 100;
+                        const taggedSearchEmails = searchPerAccount.flatMap(({ bundle, result }) => result.emails.map((email) => ({ ...email, id: withAccountPrefix(accountSlugForTag(bundle, primarySlugForSearch), email.id) })));
+                        const mergedSearchEmails = sortByDateDesc(taggedSearchEmails, (email) => email.internalDate || email.date).slice(0, searchLimit);
+                        const totalSearch = searchPerAccount.reduce((sum, { result }) => sum + result.total, 0);
+                        const warnings = searchPerAccount.flatMap(({ result }) => result.warnings ?? []);
+                        const primarySearchEntry = searchPerAccount.find(({ bundle }) => bundle.account.slug === primarySlugForSearch);
+                        return createTextResult({
+                            total: totalSearch,
+                            hasMore: totalSearch > mergedSearchEmails.length,
+                            emails: projectFields(mergedSearchEmails, parseFieldsArg(args.fields)),
+                            lastSyncAt: primarySearchEntry?.result.lastSyncAt,
+                            ...(warnings.length > 0 ? { warnings } : {}),
+                        }, false, mergedSearchEmails.map(emailSource));
                     }
                 case "get_labels":
                     {
-                        const labels = await localIndexService.getLabels(normalizeLimit(args.limit, 250));
+                        const labelsLimit = normalizeLimit(args.limit, 250);
+                        if (accountManager.all().length === 1) {
+                            const labels = await localIndexService.getLabels(labelsLimit);
+                            return createTextResult({
+                                total: labels.length,
+                                labels,
+                            });
+                        }
+                        // Merge strategy: fetch each account's own label list and sum
+                        // messageCount/unreadCount/threadCount for labels that share the same
+                        // name+type across accounts, so e.g. "INBOX" folders from two accounts
+                        // combine into one row rather than appearing as unrelated duplicates.
+                        const perAccountLabels = await Promise.all(accountManager.all().map((bundle) => bundle.localIndexService.getLabels(labelsLimit)));
+                        const mergedLabels = mergeMailboxLabels(perAccountLabels).slice(0, labelsLimit);
                         return createTextResult({
-                            total: labels.length,
-                            labels,
+                            total: mergedLabels.length,
+                            labels: mergedLabels,
                         });
                     }
                 case "get_threads":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
-                            folder: "INBOX",
-                            limitPerFolder: 100,
-                        });
-                        const result = await localIndexService.getThreads({
+                        const threadsInput = {
                             query: optionalString(args, "query"),
                             label: optionalString(args, "label"),
                             limit: typeof args.limit === "number" ? args.limit : undefined,
-                        });
-                        return createTextResult(result, false, result.threads.map(threadSource));
+                        };
+                        if (accountManager.all().length === 1) {
+                            await maybeRefreshLocalIndex(imapService, localIndexService, {
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            const result = await localIndexService.getThreads(threadsInput);
+                            return createTextResult(result, false, result.threads.map(threadSource));
+                        }
+                        // Merge strategy: refresh and query each account's own thread index
+                        // independently, tag thread ids with the account slug, concatenate,
+                        // re-sort newest-first by latestDate, then re-apply the requested
+                        // limit across the merged set and sum totals/hasMore.
+                        const primarySlugForThreads = accountManager.primary().account.slug;
+                        const threadsPerAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                            await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            return { bundle, result: await bundle.localIndexService.getThreads(threadsInput) };
+                        }));
+                        const threadsLimit = threadsInput.limit ?? 100;
+                        const taggedThreads = threadsPerAccount.flatMap(({ bundle, result }) => result.threads.map((thread) => ({
+                            ...thread,
+                            id: withAccountPrefix(accountSlugForTag(bundle, primarySlugForThreads), thread.id),
+                            messageIds: thread.messageIds.map((id) => withAccountPrefix(accountSlugForTag(bundle, primarySlugForThreads), id)),
+                        })));
+                        const mergedThreads = sortByDateDesc(taggedThreads, (thread) => thread.latestDate).slice(0, threadsLimit);
+                        const totalThreads = threadsPerAccount.reduce((sum, { result }) => sum + result.total, 0);
+                        return createTextResult({ total: totalThreads, hasMore: totalThreads > mergedThreads.length, threads: mergedThreads }, false, mergedThreads.map(threadSource));
                     }
                 case "get_actionable_threads":
                     {
-                        const refresh = await maybeRefreshLocalIndex(imapService, localIndexService, {
-                            force: normalizeBoolean(args.syncBefore, false),
-                            folder: "INBOX",
-                            limitPerFolder: 100,
-                        });
-                        const result = await localIndexService.getActionableThreads({
-                            query: optionalString(args, "query"),
-                            label: optionalString(args, "label"),
-                            pendingOn: args.pendingOn === "you" || args.pendingOn === "them" || args.pendingOn === "any"
-                                ? args.pendingOn
-                                : undefined,
-                            unreadOnly: normalizeBoolean(args.unreadOnly, true),
-                            limit: typeof args.limit === "number" ? args.limit : undefined,
-                        });
-                        return createTextResult(refresh ? { ...result, indexUpdatedAt: refresh.indexStatus.updatedAt } : result, false, result.threads.map(threadSource));
+                        const limit = typeof args.limit === "number" ? args.limit : 50;
+                        // Fan-out merge: ask every account for its own top-`limit` actionable threads
+                        // (each account's own getActionableThreads already sorts by score, then
+                        // recency — see local-index-service.ts), tag every thread/message id with its
+                        // account's slug, then merge all accounts' lists, re-sort by that exact same
+                        // (score, then latestDate) order, and take the top `limit` of the MERGED set —
+                        // never per-account. Requesting `limit` (not divided) from each account is what
+                        // makes this correct: any thread in the true global top-`limit` must already
+                        // rank within its own account's top-`limit`, since a lower rank there would mean
+                        // at least `limit` better-or-equal threads exist ahead of it account-wide alone.
+                        const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                            const refresh = await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
+                                force: normalizeBoolean(args.syncBefore, false),
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            const result = await bundle.localIndexService.getActionableThreads({
+                                query: optionalString(args, "query"),
+                                label: optionalString(args, "label"),
+                                pendingOn: args.pendingOn === "you" || args.pendingOn === "them" || args.pendingOn === "any"
+                                    ? args.pendingOn
+                                    : undefined,
+                                unreadOnly: normalizeBoolean(args.unreadOnly, true),
+                                limit,
+                            });
+                            return { bundle, refresh, result };
+                        }));
+                        const mergedThreads = perAccount
+                            .flatMap(({ bundle, result }) => tagAccountIds(slugForBundle(bundle), result.threads))
+                            .sort((left, right) => {
+                            if (right.score !== left.score)
+                                return right.score - left.score;
+                            return new Date(right.latestDate || 0).getTime() - new Date(left.latestDate || 0).getTime();
+                        })
+                            .slice(0, limit);
+                        const totalCount = perAccount.reduce((sum, { result }) => sum + result.total, 0);
+                        const messagesCapped = perAccount.some(({ result }) => result.messagesCapped);
+                        const latestRefresh = perAccount.map(({ refresh }) => refresh).find((refresh) => refresh);
+                        return createTextResult({
+                            total: totalCount,
+                            hasMore: totalCount > limit,
+                            threads: mergedThreads,
+                            ...(messagesCapped ? { messagesCapped: true } : {}),
+                            ...(latestRefresh ? { indexUpdatedAt: latestRefresh.indexStatus.updatedAt } : {}),
+                        }, false, mergedThreads.map(threadSource));
                     }
                 case "get_inbox_digest":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
-                            force: normalizeBoolean(args.syncBefore, false),
-                            folder: "INBOX",
-                            limitPerFolder: 100,
-                        });
-                        const result = await localIndexService.getInboxDigest({
-                            limit: typeof args.limit === "number" ? args.limit : undefined,
-                            minAgeHours: typeof args.minAgeHours === "number" ? args.minAgeHours : undefined,
-                        });
-                        const topThreads = Array.isArray(result.topThreads) ? result.topThreads : [];
-                        const staleThreads = Array.isArray(result.staleAwaitingYou) ? result.staleAwaitingYou : [];
-                        return createTextResult(result, false, [...topThreads, ...staleThreads]
-                            .filter((thread) => Boolean(thread && typeof thread === "object" && "id" in thread))
-                            .map(threadSource));
+                        const limit = typeof args.limit === "number" ? args.limit : 10;
+                        // Fan-out merge: get_inbox_digest already internally aggregates two lists
+                        // (topThreads by score/recency, staleAwaitingYou by score/recency) plus a
+                        // `counts` summary — mirror that same internal merge style across accounts.
+                        // Ask each account for its own top-`limit` of both lists, tag ids with the
+                        // account's slug, concatenate each list across accounts, re-sort by the same
+                        // (score, then latestDate) order the single-account version uses, and take the
+                        // top `limit` of the MERGED list (never per-account — see get_actionable_threads
+                        // for why requesting `limit`, not limit/accounts, per account is what makes this
+                        // correct). `counts` is summed across accounts field-by-field.
+                        const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                            await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
+                                force: normalizeBoolean(args.syncBefore, false),
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            const result = await bundle.localIndexService.getInboxDigest({
+                                limit,
+                                minAgeHours: typeof args.minAgeHours === "number" ? args.minAgeHours : undefined,
+                            });
+                            const slug = slugForBundle(bundle);
+                            return {
+                                counts: (result.counts ?? {}),
+                                indexUpdatedAt: result.indexUpdatedAt,
+                                topThreads: tagAccountIds(slug, (result.topThreads ?? [])),
+                                staleAwaitingYou: tagAccountIds(slug, (result.staleAwaitingYou ?? [])),
+                            };
+                        }));
+                        const byScoreThenDate = (left, right) => {
+                            if (right.score !== left.score)
+                                return right.score - left.score;
+                            return new Date(right.latestDate || 0).getTime() - new Date(left.latestDate || 0).getTime();
+                        };
+                        const topThreads = perAccount.flatMap((entry) => entry.topThreads).sort(byScoreThenDate).slice(0, limit);
+                        const staleAwaitingYou = perAccount.flatMap((entry) => entry.staleAwaitingYou).sort(byScoreThenDate).slice(0, limit);
+                        const countKeys = new Set(perAccount.flatMap((entry) => Object.keys(entry.counts)));
+                        const counts = {};
+                        for (const key of countKeys) {
+                            counts[key] = perAccount.reduce((sum, entry) => sum + (entry.counts[key] ?? 0), 0);
+                        }
+                        const result = {
+                            generatedAt: new Date().toISOString(),
+                            indexUpdatedAt: perAccount.map((entry) => entry.indexUpdatedAt).filter(Boolean).sort().reverse()[0],
+                            counts,
+                            topThreads,
+                            staleAwaitingYou,
+                        };
+                        return createTextResult(result, false, [...topThreads, ...staleAwaitingYou].map(threadSource));
                     }
                 case "get_follow_up_candidates":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
-                            force: normalizeBoolean(args.syncBefore, false),
-                            folder: "INBOX",
-                            limitPerFolder: 100,
-                        });
-                        const result = await localIndexService.getFollowUpCandidates({
-                            limit: typeof args.limit === "number" ? args.limit : undefined,
-                            minAgeHours: typeof args.minAgeHours === "number" ? args.minAgeHours : undefined,
-                            pendingOn: args.pendingOn === "you" || args.pendingOn === "them" || args.pendingOn === "any"
-                                ? args.pendingOn
-                                : undefined,
-                        });
-                        return createTextResult(result, false, Array.isArray(result.threads)
-                            ? result.threads
-                                .filter((thread) => Boolean(thread && typeof thread === "object" && "id" in thread))
-                                .map(threadSource)
-                            : []);
-                    }
-                case "find_document_threads":
-                    {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
-                            force: normalizeBoolean(args.syncBefore, false),
-                            folder: "INBOX",
-                            limitPerFolder: 100,
-                        });
-                        const result = await localIndexService.findDocumentThreads({
-                            category: args.category === "document" ||
-                                args.category === "invoice" ||
-                                args.category === "contract" ||
-                                args.category === "travel" ||
-                                args.category === "calendar"
-                                ? args.category
-                                : undefined,
-                            query: optionalString(args, "query"),
-                            limit: typeof args.limit === "number" ? args.limit : undefined,
-                        });
-                        const threads = Array.isArray(result.threads) ? result.threads : [];
+                        const limit = typeof args.limit === "number" ? args.limit : 25;
+                        // Fan-out merge: ask every account for its own top-`limit` follow-up
+                        // candidates (each account's own getFollowUpCandidates sorts by ageHours, then
+                        // score), tag ids with the account's slug, concatenate, re-sort by that same
+                        // (ageHours, then score) order, and take the top `limit` of the MERGED set —
+                        // same correctness argument as get_actionable_threads' fan-out.
+                        const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                            await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
+                                force: normalizeBoolean(args.syncBefore, false),
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            const result = await bundle.localIndexService.getFollowUpCandidates({
+                                limit,
+                                minAgeHours: typeof args.minAgeHours === "number" ? args.minAgeHours : undefined,
+                                pendingOn: args.pendingOn === "you" || args.pendingOn === "them" || args.pendingOn === "any"
+                                    ? args.pendingOn
+                                    : undefined,
+                            });
+                            return {
+                                bundle,
+                                indexUpdatedAt: result.indexUpdatedAt,
+                                threads: tagAccountIds(slugForBundle(bundle), (result.threads ?? [])),
+                                total: result.total ?? 0,
+                            };
+                        }));
+                        const threads = perAccount
+                            .flatMap((entry) => entry.threads)
+                            .sort((left, right) => {
+                            if ((right.ageHours ?? 0) !== (left.ageHours ?? 0))
+                                return (right.ageHours ?? 0) - (left.ageHours ?? 0);
+                            return right.score - left.score;
+                        })
+                            .slice(0, limit);
+                        const totalCount = perAccount.reduce((sum, entry) => sum + entry.total, 0);
+                        const result = {
+                            generatedAt: new Date().toISOString(),
+                            indexUpdatedAt: perAccount.map((entry) => entry.indexUpdatedAt).filter(Boolean).sort().reverse()[0],
+                            minAgeHours: typeof args.minAgeHours === "number" ? args.minAgeHours : 24,
+                            pendingOn: args.pendingOn === "you" || args.pendingOn === "them" || args.pendingOn === "any" ? args.pendingOn : "you",
+                            total: totalCount,
+                            hasMore: totalCount > limit,
+                            threads,
+                        };
                         return createTextResult(result, false, threads
                             .filter((thread) => Boolean(thread && typeof thread === "object" && "id" in thread))
                             .map(threadSource));
                     }
+                case "find_document_threads":
+                    {
+                        const limit = typeof args.limit === "number" ? args.limit : 25;
+                        // Fan-out merge: ask every account for its own top-`limit` document threads
+                        // (each account's own findDocumentThreads sorts by document count, then
+                        // recency), tag ids (including each document's own emailId) with the
+                        // account's slug, concatenate, re-sort by that same order, and take the top
+                        // `limit` of the MERGED set — same correctness argument as
+                        // get_actionable_threads' fan-out.
+                        const category = args.category === "document" ||
+                            args.category === "invoice" ||
+                            args.category === "contract" ||
+                            args.category === "travel" ||
+                            args.category === "calendar"
+                            ? args.category
+                            : "document";
+                        const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                            await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
+                                force: normalizeBoolean(args.syncBefore, false),
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            const result = await bundle.localIndexService.findDocumentThreads({
+                                category,
+                                query: optionalString(args, "query"),
+                                limit,
+                            });
+                            return {
+                                indexUpdatedAt: result.indexUpdatedAt,
+                                threads: tagAccountIds(slugForBundle(bundle), (result.threads ?? [])),
+                                total: result.total ?? 0,
+                            };
+                        }));
+                        const threads = perAccount
+                            .flatMap((entry) => entry.threads)
+                            .sort((left, right) => {
+                            if (right.documents.length !== left.documents.length)
+                                return right.documents.length - left.documents.length;
+                            return new Date(right.latestDate || 0).getTime() - new Date(left.latestDate || 0).getTime();
+                        })
+                            .slice(0, limit);
+                        const totalCount = perAccount.reduce((sum, entry) => sum + entry.total, 0);
+                        const result = {
+                            generatedAt: new Date().toISOString(),
+                            indexUpdatedAt: perAccount.map((entry) => entry.indexUpdatedAt).filter(Boolean).sort().reverse()[0],
+                            category,
+                            total: totalCount,
+                            hasMore: totalCount > limit,
+                            threads,
+                        };
+                        return createTextResult(result, false, threads.map(threadSource));
+                    }
                 case "prepare_meeting_context":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
-                            force: normalizeBoolean(args.syncBefore, false),
-                            folder: "INBOX",
-                            limitPerFolder: 100,
-                        });
-                        const result = await localIndexService.getMeetingPrep({
-                            person: optionalString(args, "person"),
-                            domain: optionalString(args, "domain"),
-                            limit: typeof args.limit === "number" ? args.limit : undefined,
-                        });
-                        const threads = Array.isArray(result.threads) ? result.threads : [];
-                        return createTextResult(result, false, threads
-                            .filter((thread) => Boolean(thread && typeof thread === "object" && "id" in thread))
-                            .map(threadSource));
+                        const limit = typeof args.limit === "number" ? args.limit : 10;
+                        // Fan-out merge: ask every account for its own top-`limit` meeting-prep
+                        // threads (each account's own getMeetingPrep sorts by recency — see
+                        // local-index-service.ts), tag ids with the account's slug, concatenate,
+                        // re-sort by that same recency order, and take the top `limit` of the
+                        // MERGED set — same correctness argument as get_actionable_threads' fan-out.
+                        const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                            await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
+                                force: normalizeBoolean(args.syncBefore, false),
+                                folder: "INBOX",
+                                limitPerFolder: 100,
+                            });
+                            const result = await bundle.localIndexService.getMeetingPrep({
+                                person: optionalString(args, "person"),
+                                domain: optionalString(args, "domain"),
+                                limit,
+                            });
+                            return {
+                                indexUpdatedAt: result.indexUpdatedAt,
+                                threads: tagAccountIds(slugForBundle(bundle), (result.threads ?? [])),
+                                total: result.total ?? 0,
+                            };
+                        }));
+                        const threads = perAccount
+                            .flatMap((entry) => entry.threads)
+                            .sort((left, right) => new Date(right.latestDate || 0).getTime() - new Date(left.latestDate || 0).getTime())
+                            .slice(0, limit);
+                        const totalCount = perAccount.reduce((sum, entry) => sum + entry.total, 0);
+                        const result = {
+                            generatedAt: new Date().toISOString(),
+                            indexUpdatedAt: perAccount.map((entry) => entry.indexUpdatedAt).filter(Boolean).sort().reverse()[0],
+                            total: totalCount,
+                            hasMore: totalCount > limit,
+                            threads,
+                        };
+                        return createTextResult(result, false, threads.map(threadSource));
                     }
                 case "get_thread_brief":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
+                        // Fanned out across accounts the same way emailId-targeted tools resolve a
+                        // specific account: the threadId's optional "<slug>::" prefix (from a merged
+                        // digest/follow-up/etc. result above) picks the owning account's bundle, same
+                        // pattern as resolveAccountForEmailId. A plain, unprefixed threadId still
+                        // means the primary account, unchanged from single-account behavior.
+                        const { bundle, rest } = resolveAccountForEmailId(requireString(args, "threadId"));
+                        const slug = slugForBundle(bundle);
+                        await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                             folder: "INBOX",
                             limitPerFolder: 100,
                         });
-                        const thread = await localIndexService.getThreadById(requireString(args, "threadId"));
-                        const result = buildThreadBrief(thread, config.smtp.username);
+                        const rawThread = await bundle.localIndexService.getThreadById(rest);
+                        const thread = tagAccountIds(slug, rawThread);
+                        const result = buildThreadBrief(thread, bundle.config.smtp.username);
                         return createTextResult(result, false, [
                             threadSource(thread),
                             ...thread.messages.map((message) => emailSource({
@@ -5054,13 +6174,29 @@ export function createServer(config, options = {}) {
                     }
                 case "get_thread_by_id":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
+                        // A threadId is only ever valid within the single account it was
+                        // produced by (see get_threads/search_indexed_emails above) — this is
+                        // a routed lookup, not a fan-out/merge: resolve the optional
+                        // "<slug>::" prefix (added when the id came from a non-primary
+                        // account) back to that account's bundle, defaulting to the primary
+                        // for a plain id exactly as before multi-account support existed.
+                        const rawThreadId = requireString(args, "threadId");
+                        const { accountSlug: threadAccountSlug, rest: unprefixedThreadId } = splitAccountPrefix(rawThreadId, accountManager.additionalSlugs());
+                        const threadBundle = accountManager.bySlugOrPrimary(threadAccountSlug);
+                        await maybeRefreshLocalIndex(threadBundle.imapService, threadBundle.localIndexService, {
                             folder: "INBOX",
                             limitPerFolder: 100,
                         });
                         const rawFolders = args?.folders;
                         const threadFolders = Array.isArray(rawFolders) ? rawFolders.filter((f) => typeof f === "string") : undefined;
-                        const thread = await localIndexService.getThreadById(requireString(args, "threadId"));
+                        const rawThread = await threadBundle.localIndexService.getThreadById(unprefixedThreadId);
+                        const thread = threadAccountSlug
+                            ? {
+                                ...rawThread,
+                                id: withAccountPrefix(threadAccountSlug, rawThread.id),
+                                messageIds: rawThread.messageIds.map((id) => withAccountPrefix(threadAccountSlug, id)),
+                            }
+                            : rawThread;
                         const result = threadFolders && threadFolders.length > 0
                             ? {
                                 ...thread,
@@ -5105,8 +6241,12 @@ export function createServer(config, options = {}) {
                         if (to.length === 0) {
                             throw new McpError(ErrorCode.InvalidParams, "Unable to infer reply recipient.");
                         }
+                        // Same from-based draftStore routing as create_draft — see its comment.
+                        const createThreadReplyDraftBundle = optionalString(args, "from") !== undefined
+                            ? accountManager.byAddress(optionalString(args, "from")) ?? primaryBundle
+                            : primaryBundle;
                         const result = await withAudit(auditService, name, args, async () => {
-                            const draft = await draftStore.createDraft({
+                            const draft = await createThreadReplyDraftBundle.draftStore.createDraft({
                                 mode: "reply",
                                 to,
                                 cc,
@@ -5123,7 +6263,7 @@ export function createServer(config, options = {}) {
                             });
                             const remoteSyncDecision = resolveRemoteDraftSync(config.runtime, normalizeBoolean(args.syncToRemote, true));
                             const synced = remoteSyncDecision.enabled
-                                ? await syncDraftToRemote(draftStore, smtpService, imapService, draft)
+                                ? await syncDraftToRemote(createThreadReplyDraftBundle.draftStore, createThreadReplyDraftBundle.smtpService, createThreadReplyDraftBundle.imapService, draft)
                                 : { draft, remoteSync: undefined };
                             const remoteSync = synced.remoteSync ??
                                 (remoteSyncDecision.reason
@@ -5133,9 +6273,8 @@ export function createServer(config, options = {}) {
                                         message: remoteSyncDecision.reason,
                                     }
                                     : undefined);
-                            return remoteSync
-                                ? { ...synced.draft, remoteSync, threadId: thread.id }
-                                : { ...synced.draft, threadId: thread.id };
+                            const presented = presentDraft(createThreadReplyDraftBundle, remoteSync ? { ...synced.draft, remoteSync } : synced.draft);
+                            return { ...presented, threadId: thread.id };
                         });
                         return createTextResult(result, false, [
                             draftSource(result),
@@ -5154,12 +6293,22 @@ export function createServer(config, options = {}) {
                     }
                 case "apply_thread_action":
                     {
-                        await maybeRefreshLocalIndex(imapService, localIndexService, {
+                        // A threadId only ever names ONE account — see move_thread's
+                        // identical comment on reusing resolveAccountForEmailId's generic
+                        // "<slug>::" prefix stripping for threadIds. Every message in the
+                        // resolved thread therefore belongs to this same account, so
+                        // (unlike batch_email_action's emailIds) there is nothing to
+                        // group — the whole action runs against this one bundle's own
+                        // imapService/localIndexService/auditService. Full cross-account
+                        // thread resolution is out of scope for this pass.
+                        const { bundle, rest: threadId } = resolveAccountForEmailId(requireString(args, "threadId"));
+                        const outputSlug = bundle.account.slug === primaryBundle.account.slug ? undefined : bundle.account.slug;
+                        await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                             force: normalizeBoolean(args.syncBefore, false),
                             folder: "INBOX",
                             limitPerFolder: 100,
                         });
-                        const thread = await localIndexService.getThreadById(requireString(args, "threadId"));
+                        const thread = await bundle.localIndexService.getThreadById(threadId);
                         const action = requireEmailAction(args);
                         ensureEmailActionAllowed(config.runtime, action);
                         const unreadOnly = normalizeBoolean(args.unreadOnly, false);
@@ -5173,27 +6322,33 @@ export function createServer(config, options = {}) {
                         if (action === "delete") {
                             ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Permanently delete ${emailIds.length} email(s) in thread (cannot be recovered)`);
                         }
-                        const result = await withAudit(auditService, name, args, async () => applyBatchEmailAction(imapService, [], {
+                        const result = await withAudit(bundle.auditService, name, args, async () => applyBatchEmailAction(bundle.imapService, [], {
                             emailIds,
                             action,
                             targetFolder: optionalString(args, "targetFolder"),
                             continueOnError: normalizeBoolean(args.continueOnError, true),
                             dryRun: normalizeBoolean(args.dryRun, false),
                         }));
+                        const prefixedResult = {
+                            ...result,
+                            results: result.results.map((entry) => ({ ...entry, emailId: withAccountPrefix(outputSlug, entry.emailId) })),
+                        };
                         const sources = [
                             threadSource(thread),
                             ...result.results.flatMap((entry) => (entry.ok ? emailSourceFromActionResult(entry.result) : [])),
                         ];
                         return createTextResult({
-                            threadId: thread.id,
+                            threadId: withAccountPrefix(outputSlug, thread.id),
                             unreadOnly,
                             dryRun: normalizeBoolean(args.dryRun, false),
-                            ...result,
+                            ...prefixedResult,
                         }, false, sources);
                     }
                 case "list_attachments":
                     {
-                        const attachmentList = await imapService.listAttachments(requireString(args, "emailId"));
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                        const attachmentList = await bundle.imapService.listAttachments(emailId);
                         const includeInline = normalizeBoolean(args.includeInline, true);
                         const filenameContains = optionalString(args, "filenameContains");
                         const contentType = optionalString(args, "contentType");
@@ -5212,14 +6367,17 @@ export function createServer(config, options = {}) {
                             return true;
                         });
                         const result = {
-                            emailId: attachmentList.emailId,
+                            emailId: prefixedIdFor(bundle, attachmentList.emailId),
                             attachments: filtered,
                         };
                         return createTextResult(result, false, result.attachments.map((attachment) => attachmentSource(result.emailId, attachment)));
                     }
                 case "get_attachment_content":
                     {
-                        const result = await imapService.getAttachmentContent(requireString(args, "emailId"), requireString(args, "attachmentId"), normalizeBoolean(args.includeBase64, false));
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                        const result = await bundle.imapService.getAttachmentContent(emailId, requireString(args, "attachmentId"), normalizeBoolean(args.includeBase64, false));
+                        result.emailId = prefixedIdFor(bundle, result.emailId);
                         const saveTo = optionalString(args, "saveTo");
                         if (!saveTo && result.base64) {
                             const MAX_INLINE_BYTES = (config.runtime.maxInlineBytes ?? 40) * 1024;
@@ -5273,11 +6431,16 @@ export function createServer(config, options = {}) {
                         return createTextResult(result, false, [attachmentSource(result.emailId, result.attachment)]);
                     }
                 case "get_attachment_text": {
-                    const result = await imapService.getAttachmentText(requireString(args, "emailId"), requireString(args, "attachmentId"));
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                    const result = await bundle.imapService.getAttachmentText(emailId, requireString(args, "attachmentId"));
+                    result.emailId = prefixedIdFor(bundle, result.emailId);
                     return createTextResult(result, false, [attachmentSource(result.emailId, result.attachment)]);
                 }
                 case "save_attachment":
                     {
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                         const saveTo = optionalString(args, "saveTo");
                         const outputPath = optionalString(args, "outputPath");
                         let resolvedPath = outputPath;
@@ -5294,11 +6457,15 @@ export function createServer(config, options = {}) {
                             }
                             resolvedPath = absTarget;
                         }
-                        const result = await imapService.saveAttachment(requireString(args, "emailId"), requireString(args, "attachmentId"), resolvedPath);
+                        const result = await bundle.imapService.saveAttachment(emailId, requireString(args, "attachmentId"), resolvedPath);
+                        result.emailId = prefixedIdFor(bundle, result.emailId);
                         return createTextResult(result, false, [attachmentSource(result.emailId, result.attachment)]);
                     }
                 case "export_email": {
-                    const result = await withAudit(auditService, name, args, async () => imapService.exportEmail(requireString(args, "emailId"), optionalString(args, "outputPath")));
+                    const rawEmailId = requireString(args, "emailId");
+                    const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                    const result = await withAudit(auditService, name, args, async () => bundle.imapService.exportEmail(emailId, optionalString(args, "outputPath")));
+                    result.emailId = prefixedIdFor(bundle, result.emailId);
                     return createTextResult(result);
                 }
                 case "import_email": {
@@ -5328,13 +6495,16 @@ export function createServer(config, options = {}) {
                 }
                 case "save_attachments":
                     {
-                        const result = await imapService.saveAttachments({
-                            emailId: requireString(args, "emailId"),
+                        const rawEmailId = requireString(args, "emailId");
+                        const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                        const result = await bundle.imapService.saveAttachments({
+                            emailId,
                             outputPath: optionalString(args, "outputPath"),
                             includeInline: normalizeBoolean(args.includeInline, false),
                             filenameContains: optionalString(args, "filenameContains"),
                             contentType: optionalString(args, "contentType"),
                         });
+                        result.emailId = prefixedIdFor(bundle, result.emailId);
                         return createTextResult(result, false, result.saved.map((entry) => attachmentSource(result.emailId, entry.attachment)));
                     }
                 case "clear_cache":