proton-mail-bridge-client 2.7.2 → 2.8.0

package/dist/index.js

@@ -18,6 +18,7 @@ import { ensureValidEmails, foldQuotedHistory, isTextLikeMimeType, isValidEmail,
 import { AccountManager } from "./services/account-manager.js";
 import { logger } from "./utils/logger.js";
 import { ensureDestructiveConfirmed, ensureEmailActionAllowed, ensureFlagChangeAllowed, ensureMailboxWriteAllowed, ensureOutboundRecipientsAllowed, ensureRemoteDraftSyncAllowed, ensureSendAllowed, resolveRemoteDraftSync, sanitizeRuntimeConfig, } from "./utils/runtime-policy.js";
+import { InviteError, buildInviteReply, findMyAttendee, parseInvite } from "./utils/ical-reply.js";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const PACKAGE_VERSION = packageJson.version ?? process.env.npm_package_version ?? "0.0.0";
@@ -33,6 +34,11 @@ const ALL_EMAIL_ACTIONS = [
     "move",
     "delete",
 ];
+// Triage and statistics tools cover every configured account unless told which one.
+const ACCOUNT_FILTER_PROPERTY = {
+    type: "string",
+    description: "Only this account (its address or slug). Without it the tool covers every configured account.",
+};
 const TOOLS = [
     {
         name: "send_email",
@@ -100,6 +106,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 status: { type: "string", enum: ["pending", "sending", "sent", "canceled", "failed"], description: "Filter to one status. Omit to list everything." },
                 limit: { type: "number", description: "Records per page, newest first. Default 50.", default: 50 },
                 offset: { type: "number", description: "Skip this many records (paging). Check hasMore for more." },
@@ -146,6 +153,61 @@ const TOOLS = [
             required: ["to"],
         },
     },
+    {
+        name: "set_reply_reminder",
+        description: "Remind yourself to follow up if nobody answers a message by a date. Usually used on a message you sent: it is kept as a local note, and get_inbox_digest and list_reply_reminders show it as due once the date has passed and nobody but you has written in the thread. A reply cancels the wait by itself. Setting a reminder again for the same message moves it to the new date. Changes nothing in the mailbox. Use get_follow_up_candidates instead to find sent threads that have been unanswered for a while without setting anything.",
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: "object",
+            properties: {
+                emailId: { type: "string", description: "The message to be answered (typically one from Sent)." },
+                afterDays: { type: "number", description: "Remind after this many days (1-365). Default 3. Give this or remindAt." },
+                remindAt: { type: "string", description: "Remind at this date and time (ISO 8601, in the future). Give this or afterDays." },
+                note: { type: "string", description: "Optional note shown with the reminder (up to 500 characters)." },
+            },
+            required: ["emailId"],
+        },
+    },
+    {
+        name: "list_reply_reminders",
+        description: "List your reply reminders with their state: waiting (the date has not come), due (the date has passed and nobody has answered) or answered (someone other than you wrote in the thread after the reminder was set). By default only waiting and due ones are listed, due first. The state is worked out from the local index when you ask; run sync_emails first if the index may be stale.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
+                status: { type: "string", enum: ["open", "due", "answered", "all"], description: "open = waiting and due (default).", default: "open" },
+                limit: { type: "number", description: "Maximum reminders to return.", default: 50 },
+            },
+        },
+    },
+    {
+        name: "cancel_reply_reminder",
+        description: "Delete a reply reminder by the id set_reply_reminder or list_reply_reminders gave.",
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string", description: "Reminder id." } },
+            required: ["id"],
+        },
+    },
+    {
+        name: "respond_to_invite",
+        description: "Answer a calendar invitation in a message: accept, decline or tentatively accept. Reads the invitation (the text/calendar attachment of emailId), then sends the organizer a standard calendar reply (iTIP METHOD:REPLY) from the address the invitation was sent to, so their calendar updates your status. Refuses a cancelled event, a message that is not an invitation, and an invitation without an organizer. Use dryRun to see who would be answered and what the reply says before sending. Subject to the same send settings as reply_to_email (PROTONMAIL_ALLOW_SEND, confirmation, RESTRICT_OUTBOUND_TO_SELF, send delay). Use get_email_by_id or list_attachments first if unsure whether a message holds an invitation.",
+        annotations: { destructiveHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {
+                emailId: { type: "string", description: "The message that holds the invitation." },
+                response: { type: "string", enum: ["accept", "decline", "tentative"], description: "Your answer." },
+                comment: { type: "string", description: "Optional note to the organizer (up to 1000 characters)." },
+                dryRun: { type: "boolean", description: "Show who would be answered and what the reply says, without sending.", default: false },
+                undoWindowSeconds: { type: "number", description: "Override PROTONMAIL_SEND_DELAY_SECONDS for this one send: queue it for this many seconds (cancelable via cancel_send). 0 sends immediately." },
+                confirmed: { type: "boolean", description: "Set to true to confirm this irreversible send when PROTONMAIL_CONFIRM_DESTRUCTIVE is enabled." },
+            },
+            required: ["emailId", "response"],
+        },
+    },
     {
         name: "reply_to_email",
         description: "Immediately send a reply to an existing email, threading it correctly via In-Reply-To and References headers. Use when you have an emailId and want to send the reply right away. Prefer create_reply_draft to save the reply for review first, or create_thread_reply_draft when replying from a threadId. Use reply_all_email to reply to all original recipients. Provide body (plain text, or HTML with isHtml) or markdownBody. Requires PROTONMAIL_ALLOW_SEND.",
@@ -396,6 +458,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 includeSent: { type: "boolean", description: "Include drafts already sent.", default: false },
                 limit: { type: "number", description: "Maximum drafts to return. Defaults to 20; check hasMore and page with offset for more." },
                 offset: { type: "number", description: "Number of drafts to skip, newest-updated first.", default: 0 },
@@ -409,6 +472,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 limit: { type: "number", description: "Maximum drafts to return.", default: 50 },
                 offset: { type: "number", description: "Pagination offset.", default: 0 },
             },
@@ -542,6 +606,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 folder: { type: "string", description: "Folder name.", default: "INBOX" },
                 limit: { type: "number", description: "Number of emails to return (1-250; larger values are capped at 250, use hasMore and offset/beforeUid to page).", default: 50, maximum: 250 },
                 offset: { type: "number", description: "Pagination offset from newest first.", default: 0 },
@@ -623,7 +688,7 @@ const TOOLS = [
         name: "get_folders",
         description: "Return all mailbox folders with message counts and unseen counts from the live IMAP session. Use to discover available folder names before targeting get_emails, move_email, or create_folder. Prefer sync_folders to force a fresh fetch when the folder list appears stale. Folders with noselect:true cannot be used for IMAP operations.",
         annotations: { readOnlyHint: true },
-        inputSchema: { type: "object", properties: {} },
+        inputSchema: { type: "object", properties: { account: ACCOUNT_FILTER_PROPERTY } },
     },
     {
         name: "sync_folders",
@@ -785,6 +850,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 status: { type: "string", enum: ["pending", "waking", "woken", "canceled", "failed"], description: "Filter to one status. Omit to list everything (waking = being moved back right now)." },
             },
         },
@@ -915,6 +981,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 folder: { type: "string", description: "Folder to count in. Defaults to INBOX." },
                 query: { type: "string", description: "Free-text filter." },
                 from: { type: "string", description: "Sender filter." },
@@ -939,6 +1006,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 folder: { type: "string", description: "Folder path. Defaults to INBOX.", default: "INBOX" },
             },
         },
@@ -1032,6 +1100,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 folder: { type: "string", description: "Folder to analyse. Defaults to INBOX." },
                 since: { type: "string", description: "ISO date lower bound." },
                 before: { type: "string", description: "ISO date upper bound." },
@@ -1225,6 +1294,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 days: { type: "number", description: "Trailing days window.", default: 30 },
                 limit: { type: "number", description: "Maximum messages to sample.", default: 2000 },
             },
@@ -1237,6 +1307,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 days: { type: "number", description: "Trailing days window.", default: 30 },
                 limit: { type: "number", description: "Maximum messages to sample.", default: 2000 },
             },
@@ -1249,6 +1320,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 limit: { type: "number", description: "Maximum contacts to return.", default: 100 },
             },
         },
@@ -1260,6 +1332,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 days: { type: "number", description: "Number of trailing days to include.", default: 30 },
             },
         },
@@ -1356,7 +1429,7 @@ const TOOLS = [
         name: "get_index_status",
         description: "Return metadata about the local SQLite email index: row count, last sync timestamp, index schema version, and per-folder coverage. Use to verify the index is fresh and complete before querying it with search_indexed_emails or get_threads. If the index is empty or stale, call sync_emails first.",
         annotations: { readOnlyHint: true },
-        inputSchema: { type: "object", properties: {} },
+        inputSchema: { type: "object", properties: { account: ACCOUNT_FILTER_PROPERTY } },
     },
     {
         name: "search_indexed_emails",
@@ -1393,6 +1466,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 limit: { type: "number", description: "Maximum labels to return. Capped at 250; use get_folders for the complete live folder list.", default: 250 },
             },
         },
@@ -1404,6 +1478,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 query: { type: "string", description: "Free-text filter across subject, participants, and labels." },
                 label: { type: "string", description: "Require a normalized label on the thread." },
                 folder: { type: "string", description: "Only threads with a message in this folder, by its exact path as get_folders lists it (e.g. INBOX, Archive, Trash, Folders/Receipts). With several accounts it applies to each." },
@@ -1419,6 +1494,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 query: { type: "string", description: "Free-text filter across subject, latest preview, senders, and labels." },
                 label: { type: "string", description: "Require a normalized label on the thread." },
                 pendingOn: {
@@ -1449,6 +1525,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 limit: { type: "number", description: "Maximum threads per digest section.", default: 10 },
                 offset: { type: "number", description: "Skip this many threads in each section (use paging.<section>.nextOffset from the previous response to continue).", default: 0 },
                 minAgeHours: {
@@ -1471,6 +1548,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 limit: { type: "number", description: "Maximum candidate threads to return.", default: 25 },
                 offset: { type: "number", description: "Skip this many candidates (use nextOffset from the previous response to page).", default: 0 },
                 minAgeHours: { type: "number", description: "Minimum thread age in hours.", default: 24 },
@@ -1495,6 +1573,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 category: {
                     type: "string",
                     enum: ["document", "invoice", "contract", "travel", "calendar"],
@@ -1518,6 +1597,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
+                account: ACCOUNT_FILTER_PROPERTY,
                 person: { type: "string", description: "Person name or email fragment to match." },
                 domain: { type: "string", description: "Domain to match, such as example.com." },
                 limit: { type: "number", description: "Maximum threads to include.", default: 10 },
@@ -1853,6 +1933,8 @@ const AUDIT_MAX_DEPTH = 8;
 const AUDIT_REDACTED_KEYS = new Set([
     "body", "html", "text", "htmlBody", "textBody", "markdownBody", "customMessage", "notes", "bodyEdits",
     "raw", "rawBase64", "base64", "content", "find", "replace", "signature",
+    // Parts of a received message that a tool result could carry: a preview or attachment text can hold a code or a secret.
+    "preview", "snippet", "attachmentText", "latestPreview",
 ]);
 const AUDIT_SECRET_KEY = /pass(word|wd|phrase)?$|secret|token|api[-_]?key|authoriz|credential|cookie|private[-_]?key/i;
 function sanitizeAuditValue(value, depth = 0, seen = new WeakSet()) {
@@ -1963,6 +2045,58 @@ function parseBodyEdits(value) {
         return { find: edit.find, replace: edit.replace, ...(edit.all === true ? { all: true } : {}) };
     });
 }
+// Moving a message into the Trash folder is trashing it: trash_email is literally a move there. The move tools
+// therefore need the "trash" permission as well as "move" when the destination is the Trash folder, or an
+// ALLOWED_ACTIONS list that leaves out "trash" could be sidestepped by moving to Trash instead.
+async function ensureMoveTargetAllowed(runtime, imap, targetFolder) {
+    if (!targetFolder)
+        return;
+    // A call that can span accounts is checked against every account's own Trash folder: their names may differ.
+    let unknown = false;
+    for (const candidate of Array.isArray(imap) ? imap : [imap]) {
+        const isTrash = await candidate.isTrashFolder(targetFolder);
+        if (isTrash) {
+            ensureEmailActionAllowed(runtime, "trash");
+            return;
+        }
+        if (isTrash === undefined)
+            unknown = true;
+    }
+    // Not being able to tell must not open a way round the permission: with "trash" not allowed, refuse.
+    if (unknown && !runtime.allowedActions.includes("trash")) {
+        throw new McpError(ErrorCode.InternalError, `Cannot tell whether ${targetFolder} is the Trash folder (the folder list could not be read), and the trash action is not allowed. Try again when Bridge answers.`);
+    }
+}
+// Arguments a tool does not declare are ignored (clients send extra fields, and refusing them would break
+// those clients), but silently: `folder` on get_threads did nothing for a long time and nobody was told. The
+// result now carries a note naming them, so the caller (usually a model) learns the argument had no effect.
+export function ignoredArguments(toolName, args) {
+    const tool = TOOLS.find((candidate) => candidate.name === toolName);
+    if (!tool || !args || typeof args !== "object" || Array.isArray(args)) {
+        return [];
+    }
+    const declared = new Set(Object.keys(tool.inputSchema.properties ?? {}));
+    return Object.keys(args).filter((key) => !declared.has(key));
+}
+function withIgnoredArgumentsNote(handler) {
+    return async (request) => {
+        const result = await handler(request);
+        const ignored = ignoredArguments(request.params.name, request.params.arguments);
+        if (ignored.length === 0) {
+            return result;
+        }
+        // The names come from the caller; keep the note short however many or however long they are.
+        const shown = ignored.slice(0, 10).map((key) => `"${key.length > 64 ? `${key.slice(0, 64)}...` : key}"`);
+        if (ignored.length > shown.length)
+            shown.push(`and ${ignored.length - shown.length} more`);
+        logger.warn("Tool call had arguments the tool does not accept", "MCPServer", { name: request.params.name, ignored: shown });
+        const tool = TOOLS.find((candidate) => candidate.name === request.params.name);
+        const accepted = Object.keys(tool?.inputSchema?.properties ?? {});
+        const note = `Note: ${request.params.name} does not accept ${shown.join(", ")}; ignored. ` +
+            (accepted.length > 0 ? `It accepts: ${accepted.join(", ")}.` : "It takes no arguments.");
+        return { ...result, content: [...result.content, { type: "text", text: note }] };
+    };
+}
 function asObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return {};
@@ -3728,6 +3862,37 @@ export function createServer(config, options = {}) {
         }
         return found;
     }
+    // The accounts a triage or statistics tool covers: the one named by `account`, else all of them.
+    function selectedBundles(args) {
+        const one = resolveAccountArg(args);
+        return one ? [one] : accountManager.all();
+    }
+    // A reminder as a caller sees it: ids carry the account's prefix, like every other id.
+    function presentReminder(bundle, record) {
+        const slug = responseSlug(bundle);
+        return { ...record, id: withAccountPrefix(slug, record.id), emailId: withAccountPrefix(slug, record.emailId) };
+    }
+    // Each open reminder with its state, from the local index: answered (somebody else wrote in the thread since it
+    // was set), due (the date has passed) or waiting.
+    async function evaluateReminders(bundles) {
+        const own = allAccountAddresses();
+        const now = Date.now();
+        const perAccount = await Promise.all(bundles.map(async (bundle) => {
+            const records = await bundle.replyReminderService.list();
+            return Promise.all(records.map(async (record) => {
+                const replies = await bundle.localIndexService.getRepliesSince(record.messageId, record.createdAt, own);
+                const first = [...replies].sort((left, right) => (left.internalDate || left.date || "").localeCompare(right.internalDate || right.date || ""))[0];
+                const state = first ? "answered" : new Date(record.remindAt).getTime() <= now ? "due" : "waiting";
+                return {
+                    ...presentReminder(bundle, record),
+                    state,
+                    ...(state === "due" ? { daysOverdue: Math.floor((now - new Date(record.remindAt).getTime()) / 86_400_000) } : {}),
+                    ...(first ? { answeredAt: first.internalDate || first.date, answeredBy: first.from[0]?.address } : {}),
+                };
+            }));
+        }));
+        return perAccount.flat();
+    }
     // Every configured account address — reply helpers treat all of them as "self".
     function allAccountAddresses() {
         return accountManager.all().map((bundle) => bundle.account.address);
@@ -3980,7 +4145,7 @@ export function createServer(config, options = {}) {
             }
         }
     });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, withIgnoredArgumentsNote(async (request) => {
         const name = request.params.name;
         const args = asObject(request.params.arguments);
         logger.debug("Handling tool call", "MCPServer", { name, argKeys: Object.keys(args || {}) });
@@ -4114,7 +4279,7 @@ export function createServer(config, options = {}) {
                     // a draft — see redactQueueRecordAttachments' comment. Redacted for every
                     // record regardless of status (including canceled ones, which otherwise
                     // stayed just as bloated once queued).
-                    const perAccount = await withAudit(auditService, name, args, async () => Promise.all(accountManager.all().map(async (bundle) => ({
+                    const perAccount = await withAudit(auditService, name, args, async () => Promise.all(selectedBundles(args).map(async (bundle) => ({
                         bundle,
                         items: await bundle.deliveryQueueService.list(),
                     }))));
@@ -4397,6 +4562,151 @@ export function createServer(config, options = {}) {
                         sentCopy: sentCopyTokenRa,
                     }, false, [emailSource({ ...detailRa, id: prefixedIdFor(readBundleRa, detailRa.id) })]);
                 }
+                case "set_reply_reminder": {
+                    ensureMailboxWriteAllowed(config.runtime);
+                    const { bundle: reminderBundle, rest: reminderEmailId } = resolveAccountForEmailId(requireString(args, "emailId"));
+                    const afterDays = optionalNumber(args.afterDays, 1, 365);
+                    const remindAtArg = optionalString(args, "remindAt");
+                    if (afterDays !== undefined && remindAtArg !== undefined) {
+                        throw new McpError(ErrorCode.InvalidParams, "Give afterDays or remindAt, not both.");
+                    }
+                    const now = new Date();
+                    const remindAt = remindAtArg !== undefined ? new Date(remindAtArg) : new Date(now.getTime() + (afterDays ?? 3) * 24 * 60 * 60 * 1000);
+                    if (Number.isNaN(remindAt.getTime())) {
+                        throw new McpError(ErrorCode.InvalidParams, "remindAt must be a date and time such as 2026-10-20T09:00:00Z.");
+                    }
+                    const reminderDetail = await reminderBundle.imapService.getEmailById(reminderEmailId);
+                    if (!reminderDetail.messageId) {
+                        throw new McpError(ErrorCode.InvalidParams, "This message has no Message-ID header, so replies to it cannot be recognised.");
+                    }
+                    const record = await withAudit(reminderBundle.auditService, name, args, () => reminderBundle.replyReminderService.set({
+                        emailId: reminderEmailId,
+                        messageId: reminderDetail.messageId,
+                        subject: reminderDetail.subject,
+                        to: reminderDetail.to.map((address) => address.address ?? "").filter(Boolean),
+                        remindAt,
+                        note: optionalString(args, "note"),
+                        now,
+                    }));
+                    return createTextResult({ ...presentReminder(reminderBundle, record), state: "waiting" });
+                }
+                case "list_reply_reminders": {
+                    const status = optionalString(args, "status") ?? "open";
+                    if (!["open", "due", "answered", "all"].includes(status)) {
+                        throw new McpError(ErrorCode.InvalidParams, "status must be open, due, answered or all.");
+                    }
+                    const limit = normalizeLimit(args.limit, 50, 1, 500);
+                    const bundles = selectedBundles(args);
+                    await Promise.all(bundles.map((bundle) => maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, { force: false, folder: "INBOX", limitPerFolder: 100 })));
+                    const all = await evaluateReminders(bundles);
+                    const wanted = all.filter((reminder) => (status === "all" ? true : status === "open" ? reminder.state !== "answered" : reminder.state === status));
+                    const rank = { due: 0, waiting: 1, answered: 2 };
+                    wanted.sort((left, right) => rank[left.state] - rank[right.state] || left.remindAt.localeCompare(right.remindAt));
+                    return createTextResult({
+                        total: wanted.length,
+                        due: all.filter((reminder) => reminder.state === "due").length,
+                        reminders: wanted.slice(0, limit),
+                    });
+                }
+                case "cancel_reply_reminder": {
+                    ensureMailboxWriteAllowed(config.runtime);
+                    const { bundle: cancelBundle, rest: reminderId } = resolveAccountForEmailId(requireString(args, "id"));
+                    const result = await withAudit(cancelBundle.auditService, name, args, () => cancelBundle.replyReminderService.cancel(reminderId));
+                    return createTextResult({ id: requireString(args, "id"), canceled: result.canceled });
+                }
+                case "respond_to_invite": {
+                    ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Answer calendar invitation ${String(args.emailId ?? "?")}`);
+                    ensureSendAllowed(config.runtime);
+                    const { bundle: inviteBundle, rest: inviteEmailId } = resolveAccountForEmailId(requireString(args, "emailId"));
+                    const responseArg = requireString(args, "response");
+                    if (responseArg !== "accept" && responseArg !== "decline" && responseArg !== "tentative") {
+                        throw new McpError(ErrorCode.InvalidParams, "response must be accept, decline or tentative.");
+                    }
+                    const inviteComment = optionalString(args, "comment");
+                    if (inviteComment !== undefined && inviteComment.length > 1000) {
+                        throw new McpError(ErrorCode.InvalidParams, "comment must be at most 1000 characters.");
+                    }
+                    const inviteDetail = await inviteBundle.imapService.getEmailById(inviteEmailId);
+                    const candidates = (inviteDetail.attachments ?? []).filter((attachment) => Boolean(attachment.id) &&
+                        (attachment.isCalendarInvite || attachment.kind === "calendar" || /text\/calendar/i.test(attachment.contentType ?? "") || /\.ics$/i.test(attachment.filename ?? "")));
+                    if (candidates.length === 0) {
+                        throw new McpError(ErrorCode.InvalidParams, "This message has no calendar invitation attachment.");
+                    }
+                    let invite;
+                    let inviteProblem;
+                    for (const candidate of candidates) {
+                        const content = await inviteBundle.imapService.getAttachmentContent(inviteEmailId, candidate.id, { includeBase64: true });
+                        try {
+                            invite = parseInvite(Buffer.from(content.base64 ?? "", "base64").toString("utf8"));
+                            break;
+                        }
+                        catch (error) {
+                            if (!(error instanceof InviteError))
+                                throw error;
+                            inviteProblem ??= error.message;
+                        }
+                    }
+                    if (!invite) {
+                        throw new McpError(ErrorCode.InvalidParams, inviteProblem ?? "No invitation could be read from this message.");
+                    }
+                    // Answer as the account that holds the message. Only an attendee address that is exactly one of our
+                    // accounts is used; a "+tag" or alias address in a hostile invite never picks the sender.
+                    const myAddresses = allAccountAddresses();
+                    const myAttendee = findMyAttendee(invite, (address) => myAddresses.some((own) => own.toLowerCase() === address.toLowerCase()));
+                    const attendeeBundle = myAttendee ? accountManager.byAddress(myAttendee.address) : undefined;
+                    const inviteSendBundle = attendeeBundle ?? inviteBundle;
+                    const answeringAs = inviteSendBundle.config.smtp.username;
+                    const inviteReply = buildInviteReply(invite, {
+                        attendeeAddress: answeringAs,
+                        attendeeName: myAttendee?.name,
+                        response: responseArg,
+                        comment: inviteComment,
+                    });
+                    const inviteTo = [inviteReply.to];
+                    ensureValidEmails(inviteTo, "to");
+                    ensureOutboundRecipientsAllowed(config.runtime, inviteSendBundle.config.smtp.username, inviteTo);
+                    const senderDomains = (inviteDetail.from ?? []).map((entry) => (entry.address ?? "").split("@").pop()?.toLowerCase());
+                    const organizerDomain = invite.organizer.address.split("@").pop()?.toLowerCase();
+                    const organizerMismatch = !senderDomains.includes(organizerDomain);
+                    const inviteSummary = {
+                        event: invite.summary ?? "(no title)",
+                        ...(organizerMismatch
+                            ? { warning: `The organizer (${invite.organizer.address}) is not the sender of this message; the answer goes to the organizer, so check that you trust them.` }
+                            : {}),
+                        organizer: invite.organizer.address,
+                        answeringAs,
+                        response: responseArg,
+                        previousStatus: myAttendee?.partstat,
+                        ...(invite.hasRecurrence ? { note: "This invitation repeats; the answer applies to the whole series." } : {}),
+                    };
+                    if (normalizeBoolean(args.dryRun, false)) {
+                        return createTextResult({ dryRun: true, wouldSendTo: inviteTo, subject: inviteReply.subject, ...inviteSummary, replyCalendar: inviteReply.ics.split("\r\n").filter(Boolean), note: "No email was sent." });
+                    }
+                    const invitePayload = {
+                        to: inviteTo,
+                        subject: inviteReply.subject,
+                        body: inviteReply.body,
+                        from: inviteSendBundle.config.smtp.username === answeringAs ? undefined : answeringAs,
+                        inReplyTo: inviteDetail.messageId,
+                        references: replyReferences(inviteDetail),
+                        icalEvent: { method: "REPLY", content: inviteReply.ics },
+                        appendSignature: false,
+                    };
+                    const inviteUndo = resolveUndoWindowSeconds(args);
+                    if (inviteUndo > 0) {
+                        return queueUndoSend(inviteSendBundle, invitePayload, inviteUndo, name, args, { to: inviteTo, ...inviteSummary });
+                    }
+                    const inviteResult = await withAudit(auditService, name, args, async () => inviteSendBundle.smtpService.sendEmail(invitePayload));
+                    return createTextResult({
+                        ...inviteSummary,
+                        to: inviteTo,
+                        subject: inviteReply.subject,
+                        messageId: inviteResult.messageId,
+                        accepted: inviteResult.accepted,
+                        rejected: inviteResult.rejected,
+                        response_: inviteResult.response,
+                    }, false, [emailSource({ ...inviteDetail, id: prefixedIdFor(inviteBundle, inviteDetail.id) })]);
+                }
                 case "forward_email": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Forward email ${String(args.emailId ?? "?")} to ${String(args.to ?? "?")}`);
                     ensureSendAllowed(config.runtime);
@@ -4760,9 +5070,10 @@ export function createServer(config, options = {}) {
                     // account's own list already arrives that way). Single-account guard
                     // keeps byte-identical output for the common case.
                     const includeSent = normalizeBoolean(args.includeSent, false);
+                    resolveAccountArg(args);
                     const allDrafts = accountManager.all().length === 1
                         ? (await draftStore.listDrafts(includeSent)).map((draft) => ({ bundle: primaryBundle, draft }))
-                        : (await Promise.all(accountManager.all().map(async (bundle) => {
+                        : (await Promise.all(selectedBundles(args).map(async (bundle) => {
                             const drafts = await bundle.draftStore.listDrafts(includeSent);
                             return drafts.map((draft) => ({ bundle, draft: presentDraft(bundle, draft) }));
                         })))
@@ -4789,7 +5100,11 @@ export function createServer(config, options = {}) {
                 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));
+                    // `account` picks another account's Drafts mailbox; its ids carry that account's prefix like everywhere else.
+                    const draftsBundle = resolveAccountArg(args) ?? primaryBundle;
+                    const draftsSlug = responseSlug(draftsBundle);
+                    const rawResult = await draftsBundle.imapService.listRemoteDrafts(normalizeLimit(args.limit, 50), normalizeLimit(args.offset, 0, 0, 10_000));
+                    const result = { ...rawResult, emails: rawResult.emails.map((email) => ({ ...email, id: withAccountPrefix(draftsSlug, email.id) })) };
                     // projectFields (called with no fields arg) still trims each email's
                     // attachments to the essentials — same fix as every other list-style
                     // tool, this one just didn't route through projectFields at all before.
@@ -5267,6 +5582,7 @@ export function createServer(config, options = {}) {
                         includeSnippet: normalizeBoolean(args.includeSnippet, false),
                     };
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const result = await imapService.getEmails(getEmailsInput);
                         return createTextResult({
                             ...result,
@@ -5308,7 +5624,7 @@ export function createServer(config, options = {}) {
                     // than inferring it from a count that can be either capped-by-fetch or
                     // filter-blind depending on which one you pick.
                     const perAccountFetchLimit = requestedOffset + effectiveLimit + 1;
-                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                    const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                         const result = await bundle.imapService.getEmails({ ...getEmailsInput, offset: 0, limit: perAccountFetchLimit });
                         return { bundle, result };
                     }));
@@ -5528,6 +5844,7 @@ export function createServer(config, options = {}) {
                         sizeSmaller: optionalNumber(args.sizeSmaller, 0, Number.MAX_SAFE_INTEGER),
                     };
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const result = await imapService.countMessages(countInput);
                         return createTextResult(result);
                     }
@@ -5536,7 +5853,7 @@ export function createServer(config, options = {}) {
                     // folder name), with a per-account breakdown alongside the total.
                     // One account lacking the folder or label (or unreachable) must not fail the whole count, as in
                     // search_emails: report it and return the rest. Every account failing still throws.
-                    const settled = await Promise.allSettled(accountManager.all().map(async (bundle) => ({
+                    const settled = await Promise.allSettled(selectedBundles(args).map(async (bundle) => ({
                         slug: bundle.account.slug,
                         ...(await bundle.imapService.countMessages(countInput)),
                     })));
@@ -5545,7 +5862,7 @@ export function createServer(config, options = {}) {
                         throw settled[0].reason;
                     }
                     const failedAccounts = settled.flatMap((entry, index) => entry.status === "rejected"
-                        ? [{ account: accountManager.all()[index].account.slug, error: entry.reason instanceof Error ? entry.reason.message : String(entry.reason) }]
+                        ? [{ account: selectedBundles(args)[index].account.slug, error: entry.reason instanceof Error ? entry.reason.message : String(entry.reason) }]
                         : []);
                     return createTextResult({
                         folder: countInput.folder ?? "INBOX",
@@ -5558,13 +5875,14 @@ export function createServer(config, options = {}) {
                 case "folder_stats": {
                     const folderStatsFolder = optionalString(args, "folder");
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const result = await imapService.getFolderStats(folderStatsFolder);
                         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) => ({
+                    const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => ({
                         slug: bundle.account.slug,
                         ...(await bundle.imapService.getFolderStats(folderStatsFolder)),
                     })));
@@ -5610,6 +5928,7 @@ export function createServer(config, options = {}) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide emailIds OR match, not both.");
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const targetFolder = requireString(args, "targetFolder");
+                    await ensureMoveTargetAllowed(config.runtime, accountManager.all().map((entry) => entry.imapService), targetFolder);
                     const max = getBulkMaxBatchSize(args);
                     const dryRun = normalizeBoolean(args.dryRun, false);
                     // emailIds can span multiple configured accounts (a "<slug>::"
@@ -5883,6 +6202,7 @@ export function createServer(config, options = {}) {
                         excludeSelf: normalizeBoolean(args.excludeSelf, true),
                     };
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const result = await imapService.topSenders(topSendersInput);
                         return createTextResult(result);
                     }
@@ -5891,7 +6211,7 @@ export function createServer(config, options = {}) {
                     // re-sort and re-apply the requested top-N limit over the merged set.
                     // Each account is asked for its WHOLE table, not just its own top N: a sender in the middle of every
                     // account's table can still be first in total, and cutting each table first made it disappear.
-                    const perAccount = await Promise.all(accountManager.all().map(async (bundle) => ({
+                    const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => ({
                         bundle,
                         result: await bundle.imapService.topSenders({ ...topSendersInput, limit: 10_000 }),
                     })));
@@ -5927,6 +6247,7 @@ export function createServer(config, options = {}) {
                     // (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"));
+                    await ensureMoveTargetAllowed(config.runtime, bundle.imapService, requireString(args, "destination"));
                     const result = await withAudit(bundle.auditService, name, args, () => bundle.imapService.moveThread({
                         messageId,
                         destination: requireString(args, "destination"),
@@ -6009,6 +6330,7 @@ export function createServer(config, options = {}) {
                 }
                 case "get_folders": {
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         return createTextResult(await imapService.getFolders());
                     }
                     // Merge strategy: fetch each account's own folder list (LIVE IMAP) and
@@ -6016,7 +6338,7 @@ export function createServer(config, options = {}) {
                     // 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 perAccount = await Promise.all(selectedBundles(args).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;
@@ -6055,6 +6377,7 @@ export function createServer(config, options = {}) {
                         const rawEmailId = requireString(args, "emailId");
                         const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
                         const targetFolder = requireString(args, "targetFolder");
+                        await ensureMoveTargetAllowed(config.runtime, bundle.imapService, targetFolder);
                         const uidValidity = parseEmailId(emailId).uidValidity;
                         const result = await withAudit(auditService, name, args, async () => {
                             try {
@@ -6128,6 +6451,7 @@ export function createServer(config, options = {}) {
                         ensureEmailActionAllowed(config.runtime, "restore");
                         const rawEmailId = requireString(args, "emailId");
                         const { bundle, rest: emailId } = resolveAccountForEmailId(rawEmailId);
+                        await ensureMoveTargetAllowed(config.runtime, bundle.imapService, optionalString(args, "targetFolder"));
                         const uidValidity = parseEmailId(emailId).uidValidity;
                         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;
@@ -6190,11 +6514,12 @@ export function createServer(config, options = {}) {
                     // independent snoozeService/JSON file. Single-account guard keeps
                     // byte-identical output for the common case.
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const all = await withAudit(auditService, name, args, async () => snoozeService.list());
                         const filtered = statusFilter ? all.filter((item) => item.status === statusFilter) : all;
                         return createTextResult(filtered);
                     }
-                    const perAccount = await withAudit(auditService, name, args, async () => Promise.all(accountManager.all().map(async (bundle) => ({
+                    const perAccount = await withAudit(auditService, name, args, async () => Promise.all(selectedBundles(args).map(async (bundle) => ({
                         bundle,
                         items: await bundle.snoozeService.list(),
                     }))));
@@ -6276,6 +6601,9 @@ export function createServer(config, options = {}) {
                         const continueOnError = normalizeBoolean(args.continueOnError, true);
                         const dryRun = normalizeBoolean(args.dryRun, false);
                         const targetFolder = optionalString(args, "targetFolder");
+                        if (action === "move" || action === "restore") {
+                            await ensureMoveTargetAllowed(config.runtime, accountManager.all().map((entry) => entry.imapService), targetFolder);
+                        }
                         const groups = groupEmailIdsByAccount(accountManager, emailIds);
                         const groupResults = [];
                         for (const [slug, group] of groups) {
@@ -6316,6 +6644,7 @@ export function createServer(config, options = {}) {
                     const statsDays = normalizeLimit(args.days, 30, 1, 365);
                     const statsLimit = normalizeLimit(args.limit, 2000, 1, 10_000);
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const folders = await imapService.getFolders();
                         const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, statsDays, statsLimit);
                         return createTextResult(analyticsService.getEmailStats(sample, folders, config.smtp.username));
@@ -6325,7 +6654,7 @@ export function createServer(config, options = {}) {
                     // 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 statsPerAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                         const folders = await bundle.imapService.getFolders();
                         const sample = await getAnalyticsSampleFromIndex(bundle.imapService, bundle.localIndexService, statsDays, statsLimit);
                         return {
@@ -6357,6 +6686,7 @@ export function createServer(config, options = {}) {
                     const analyticsDays = normalizeLimit(args.days, 30, 1, 365);
                     const analyticsLimit = normalizeLimit(args.limit, 2000, 1, 10_000);
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, analyticsDays, analyticsLimit);
                         return createTextResult(analyticsService.getEmailAnalytics(sample, config.smtp.username, analyticsDays));
                     }
@@ -6365,7 +6695,7 @@ export function createServer(config, options = {}) {
                     // 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 analyticsPerAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                         const sample = await getAnalyticsSampleFromIndex(bundle.imapService, bundle.localIndexService, analyticsDays, analyticsLimit);
                         return analyticsService.getEmailAnalytics(sample, bundle.config.smtp.username, analyticsDays);
                     }));
@@ -6404,6 +6734,7 @@ export function createServer(config, options = {}) {
                     // meant limit: 5 silently ranked contacts from only 5 messages total.
                     const limit = normalizeLimit(args.limit, 100);
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         const sample = await getAnalyticsSampleFromIndex(imapService, localIndexService, 30, 3000);
                         return createTextResult(analyticsService.getContacts(sample, limit, config.smtp.username));
                     }
@@ -6412,7 +6743,7 @@ export function createServer(config, options = {}) {
                     // 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 contactsPerAccount = await Promise.all(selectedBundles(args).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);
                     }));
@@ -6422,13 +6753,14 @@ export function createServer(config, options = {}) {
                     const days = normalizeLimit(args.days, 30, 1, 365);
                     // Counted in SQL over the whole index (a sample of the newest 3000 messages cut the older days short).
                     if (accountManager.all().length === 1) {
+                        resolveAccountArg(args);
                         await maybeRefreshLocalIndex(imapService, localIndexService, {});
                         return createTextResult(await localIndexService.getDailyVolume(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 trendsPerAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                         await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {});
                         return bundle.localIndexService.getDailyVolume(days);
                     }));
@@ -6829,8 +7161,9 @@ export function createServer(config, options = {}) {
                     }
                 case "get_index_status":
                     {
-                        const indexStatus = await localIndexService.getStatus();
-                        const syncCfg = backgroundSyncService.getStatus();
+                        const statusBundle = resolveAccountArg(args) ?? primaryBundle;
+                        const indexStatus = await statusBundle.localIndexService.getStatus();
+                        const syncCfg = statusBundle.backgroundSyncService.getStatus();
                         return createTextResult({
                             ...indexStatus,
                             // What keeps this index current, so a stale/missing message can be explained:
@@ -6901,6 +7234,7 @@ export function createServer(config, options = {}) {
                     {
                         const labelsLimit = normalizeLimit(args.limit, 250);
                         if (accountManager.all().length === 1) {
+                            resolveAccountArg(args);
                             const labels = await localIndexService.getLabels(labelsLimit);
                             return createTextResult({
                                 total: labels.length,
@@ -6911,7 +7245,7 @@ export function createServer(config, options = {}) {
                         // 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 perAccountLabels = await Promise.all(selectedBundles(args).map((bundle) => bundle.localIndexService.getLabels(labelsLimit)));
                         const mergedLabels = mergeMailboxLabels(perAccountLabels).slice(0, labelsLimit);
                         return createTextResult({
                             total: mergedLabels.length,
@@ -6928,6 +7262,7 @@ export function createServer(config, options = {}) {
                             offset: optionalInteger(args.offset, 0, 1_000_000),
                         };
                         if (accountManager.all().length === 1) {
+                            resolveAccountArg(args);
                             await maybeRefreshLocalIndex(imapService, localIndexService, {
                                 folder: "INBOX",
                                 limitPerFolder: 100,
@@ -6941,7 +7276,7 @@ export function createServer(config, options = {}) {
                         // 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) => {
+                        const threadsPerAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                             await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                                 folder: "INBOX",
                                 limitPerFolder: 100,
@@ -6985,7 +7320,7 @@ export function createServer(config, options = {}) {
                         // 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 perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                             const refresh = await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                                 force: normalizeBoolean(args.syncBefore, false),
                                 folder: "INBOX",
@@ -7041,7 +7376,7 @@ export function createServer(config, options = {}) {
                         // 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) => {
+                        const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                             await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                                 force: normalizeBoolean(args.syncBefore, false),
                                 folder: "INBOX",
@@ -7076,6 +7411,8 @@ export function createServer(config, options = {}) {
                         for (const key of countKeys) {
                             counts[key] = perAccount.reduce((sum, entry) => sum + (entry.counts[key] ?? 0), 0);
                         }
+                        // Reply reminders whose date has passed with no answer: they belong in a triage summary.
+                        const dueReminders = (await evaluateReminders(selectedBundles(args))).filter((reminder) => reminder.state === "due");
                         const result = {
                             generatedAt: new Date().toISOString(),
                             indexUpdatedAt: perAccount.map((entry) => entry.indexUpdatedAt).filter(Boolean).sort().reverse()[0],
@@ -7085,6 +7422,7 @@ export function createServer(config, options = {}) {
                                 : {}),
                             topThreads,
                             staleAwaitingYou,
+                            ...(dueReminders.length > 0 ? { repliesDue: dueReminders.slice(0, 10), repliesDueTotal: dueReminders.length } : {}),
                             // Each section pages independently with the same offset/limit: pass nextOffset back as
                             // `offset` to continue (a section with hasMore:false is exhausted).
                             paging: {
@@ -7104,7 +7442,7 @@ export function createServer(config, options = {}) {
                         // 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) => {
+                        const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                             await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                                 force: normalizeBoolean(args.syncBefore, false),
                                 folder: "INBOX",
@@ -7163,7 +7501,7 @@ export function createServer(config, options = {}) {
                             args.category === "calendar"
                             ? args.category
                             : "document";
-                        const perAccount = await Promise.all(accountManager.all().map(async (bundle) => {
+                        const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                             await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                                 force: normalizeBoolean(args.syncBefore, false),
                                 folder: "INBOX",
@@ -7207,7 +7545,7 @@ export function createServer(config, options = {}) {
                         // 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) => {
+                        const perAccount = await Promise.all(selectedBundles(args).map(async (bundle) => {
                             await maybeRefreshLocalIndex(bundle.imapService, bundle.localIndexService, {
                                 force: normalizeBoolean(args.syncBefore, false),
                                 folder: "INBOX",
@@ -7433,6 +7771,9 @@ export function createServer(config, options = {}) {
                         const thread = await bundle.localIndexService.getThreadById(threadId);
                         const action = requireEmailAction(args);
                         ensureEmailActionAllowed(config.runtime, action);
+                        if (action === "move" || action === "restore") {
+                            await ensureMoveTargetAllowed(config.runtime, bundle.imapService, optionalString(args, "targetFolder"));
+                        }
                         const unreadOnly = normalizeBoolean(args.unreadOnly, false);
                         const emailIds = [...new Set(thread.messages
                                 .filter((message) => !unreadOnly || !message.isRead)
@@ -7674,7 +8015,7 @@ export function createServer(config, options = {}) {
                 ?? "An internal error occurred. Check get_logs for details, or run run_doctor for a full connectivity check.";
             throw new McpError(ErrorCode.InternalError, message);
         }
-    });
+    }));
     return {
         server,
         smtpService,