proton-mail-bridge-client 2.0.9 → 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);
@@ -143,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"],
@@ -323,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.",
@@ -361,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.",
@@ -1241,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.",
@@ -1514,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.",
@@ -2134,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
@@ -2402,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
@@ -2546,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 [];
     }
@@ -2591,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;
     }
@@ -2610,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);
 }
@@ -2745,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");
@@ -2789,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,
@@ -2835,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",
@@ -3070,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({
@@ -3079,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]";
                         }
@@ -3109,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,
@@ -3122,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) {
@@ -3135,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,
@@ -3154,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,
@@ -3168,7 +3555,13 @@ 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);
@@ -3179,11 +3572,13 @@ export function createServer(config, options = {}) {
                     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");
@@ -3207,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,
@@ -3230,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,
@@ -3245,12 +3640,14 @@ 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);
@@ -3260,11 +3657,13 @@ export function createServer(config, options = {}) {
                     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");
@@ -3290,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,
@@ -3311,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,
@@ -3326,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"));
@@ -3344,6 +3745,8 @@ export function createServer(config, options = {}) {
                     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
@@ -3386,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,
@@ -3412,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,
@@ -3427,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"));
@@ -3448,8 +3851,13 @@ export function createServer(config, options = {}) {
                     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,
@@ -3467,7 +3875,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(createDraftBundle.draftStore, createDraftBundle.smtpService, createDraftBundle.imapService, draft)
                             : { draft, remoteSync: undefined };
                         const remoteSync = synced.remoteSync ??
                             (remoteSyncDecision.reason
@@ -3477,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),
@@ -3509,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,
@@ -3527,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
@@ -3537,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),
@@ -3575,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,
@@ -3591,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
@@ -3601,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),
@@ -3618,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,
@@ -3625,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
@@ -3644,7 +4066,7 @@ 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"));
@@ -3668,7 +4090,7 @@ export function createServer(config, options = {}) {
                         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,
@@ -3685,7 +4107,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(updateDraftBundle.draftStore, updateDraftBundle.smtpService, updateDraftBundle.imapService, draft)
                             : { draft, remoteSync: undefined };
                         const remoteSync = synced.remoteSync ??
                             (remoteSyncDecision.reason
@@ -3695,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),
@@ -3712,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,
                                 })
                             ]
                             : []),
@@ -3730,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
@@ -3743,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.`);
                     }
@@ -3784,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
@@ -3798,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,
@@ -3822,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(),
@@ -3851,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
@@ -3869,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]";
                         }
@@ -3898,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
@@ -3923,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.`);
                     }
@@ -3949,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,
@@ -3969,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
@@ -3990,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,
                         };
                     });
@@ -3999,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);
@@ -4026,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"))];
@@ -4095,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)
                         : [];
@@ -4110,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)
                         : [];
@@ -4126,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"),
@@ -4146,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) {
@@ -4189,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);
@@ -4242,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);
@@ -4300,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);
@@ -4334,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),
@@ -4378,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),
@@ -4392,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),
@@ -4433,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":
@@ -4449,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)) {
@@ -4476,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");
@@ -4608,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":
                     {
@@ -4627,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
@@ -4653,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";
@@ -4761,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
@@ -4836,6 +5659,7 @@ export function createServer(config, options = {}) {
                                 "vacation responder (Proton account API only, not exposed via Bridge)",
                             ],
                         },
+                        accounts: accountsInfo,
                     });
                 }
                 case "get_runtime_status": {
@@ -4843,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),
@@ -4858,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":
@@ -4931,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"),
@@ -4948,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({
@@ -5092,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,
@@ -5143,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,
@@ -5161,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
@@ -5171,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),
@@ -5192,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);
@@ -5211,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");
@@ -5250,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;
@@ -5311,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;
@@ -5332,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": {
@@ -5366,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":