outlook-classic-mcp
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
outlook-classic-mcp

A local MCP (Model Context Protocol) server that exposes the classic Outlook desktop client — mail, folders, calendar, contacts, tasks, color categories, mail rules, and Out-of-Office status — to any MCP-aware agent: Claude Code, Claude Desktop, Cowork, GitHub Copilot / VS Code agent mode, Cursor, Cline, Continue, Windsurf, and anything else that speaks MCP.
It talks to Outlook's COM API on Windows via pywin32, the same path
macros and Office add-ins use. Authentication piggybacks on whatever
account Outlook is already signed into — no Azure / Entra app
registration, no Microsoft Graph API, no OAuth tokens. That also means
it works the same with on-premises Exchange, ADFS or any other sign-in
Outlook itself handles.
This is a fork of anasahmed07/Outlook-Classic-MCP that adds threaded reply/forward drafts, sending a reviewed draft, signatures, draft-only mode on by default, other people's calendars and a scheduling assistant, fuller calendar support, and the fixes from the upstream pull requests that were still waiting to be merged. See What's different in this fork.
Requirements
Windows 10 or 11
Outlook desktop (Classic) — the
OUTLOOK.EXEshipped with Microsoft 365 / Office. The "new Outlook" (olk.exe) is not supported (no COM surface).Python 3.10+ (the installer fetches Python 3.11 via
uvif you don't already have one).
You do not need to open Outlook before starting the server — the server auto-launches Outlook on its first COM call.
Related MCP server: Outlook MCP Server
Install
Option 1 — Claude Code plugin (recommended)
This repository is a Claude Code plugin marketplace. In Claude Code on the Windows machine with classic Outlook:
/plugin marketplace add Heknon/outlook-classic-mcp
/plugin install outlook@outlook-classic-mcpRestart Claude Code. That's all — nothing to install beforehand. The plugin brings:
the MCP server (all
outlook_*tools),a start-up hook that sets up the runtime the first time: it installs
uvfor your user if it's missing, and uv downloads a suitable Python and the dependencies into the plugin's data folder. No admin rights needed. Ifuvcan't be downloaded (blocked by the network or script policy), an installed Python 3.10+ is used instead. Corporate TLS inspection is handled by trusting the Windows certificate store.
The first start takes a minute or so while this happens. If the Outlook
tools don't show up in that first session, run /mcp and reconnect
plugin:outlook:outlook, or restart Claude Code. Later starts are instant.
Confirm with outlook_whoami.
Updating: /plugin marketplace update outlook-classic-mcp, then
/plugin update outlook@outlook-classic-mcp. Uninstalling the plugin
removes its environment too.
Settings go in ~/.claude/settings.json under "env" (for example
"OUTLOOK_MCP_ALLOW_SEND": "1"), see Environment variables.
Launcher-only switches: OUTLOOK_MCP_RUNTIME=python (never use uv) and
OUTLOOK_MCP_NO_AUTO_INSTALL=1 (don't download uv).
Option 2 — From a clone (any MCP client)
git clone https://github.com/Heknon/outlook-classic-mcp
cd outlook-classic-mcp
install.batinstall.bat creates a .venv, installs the package, and runs the
client installer below to register the server with Claude Desktop,
Claude Code, Cursor, Cline, Continue or Windsurf.
Option 3 — Manual registration
claude mcp add outlook -- uvx --from git+https://github.com/Heknon/outlook-classic-mcp outlook-mcpAppend @<commit or tag> to the URL to pin a version. For other clients
see Manual config.
Smart client installer
scripts/install_to_clients.py detects which MCP clients are
installed on your machine and shows a checkbox menu:
Select which clients to register outlook-mcp with:
[ ] 1. Claude Desktop C:\Users\you\AppData\Roaming\Claude\claude_desktop_config.json
[ ] 2. Claude Code (via `claude` CLI)
[ ] 3. Cursor C:\Users\you\.cursor\mcp.json
Type a number to toggle, 'a' to select all, 'n' for none,
'enter' to confirm, 'q' to quit without changes.For each toggled client it deep-merges
mcpServers.outlook = {"command": ".venv/Scripts/python.exe", "args": ["-m", "outlook_mcp"]}
into the right config (or runs claude mcp add for Claude Code).
Existing files are snapshotted to <file>.bak first. Re-running is
idempotent — it updates the entry instead of duplicating it.
Supported clients: Claude Desktop, Claude Code, Cursor, Cline, Continue, Windsurf.
Manual config (any other MCP client)
Any client not covered by the installer just needs the standard stdio server entry in its MCP config:
{
"mcpServers": {
"outlook": {
"command": "uvx",
"args": ["--from", "git+https://github.com/Heknon/outlook-classic-mcp", "outlook-mcp"]
}
}
}(VS Code / Copilot agent mode names the top-level key servers in
mcp.json instead of mcpServers; the entry itself is the same. To let
the server send, add "env": { "OUTLOOK_MCP_ALLOW_SEND": "1" } — see
Safety.)
Tools
49 tools across 10 categories, all prefixed outlook_*.
Category | Tools |
| |
Inbox zero |
|
Folders |
|
Calendar |
|
Contacts |
|
Tasks |
|
Categories |
|
Rules |
|
Out-of-Office |
|
Account |
|
Searching everywhere
search_mails and search_mails_by_person search one folder by default.
With search_in they search every folder of:
"mailbox"— your mailbox,"archive"— your online / in-place archive,"all"— every mailbox in your Outlook profile: yours, the archive, shared and delegate mailboxes, and PST files,
or mailboxes=["Support"] for specific ones (list_mailboxes lists
them). Results are newest first and show the folder path of each mail.
Deleted Items and Junk are skipped unless include_deleted=true. The
archive and shared mailboxes must be open in Outlook's folder pane.
People
resolve_nameworks like Ctrl+K: give it a full or partial name or alias and get the person's address, title, department and office. If several people match, it returns the candidates to choose from.search_mails_by_person(person="Dana", direction="from")finds mails from and/or to someone by name, across Inbox and Sent Items.
Inbox zero
Your Quick Steps are the buckets.
list_quick_stepsreads the Quick Steps you set up in Outlook (Archive, Action, Waiting, Read, ...) and shows what each does;run_quick_step(name, entry_ids)does the same thing to the messages you pick. Outlook has no API for Quick Steps, so they're read from where Outlook stores them in your mailbox (hidden XML). Supported actions: move, copy, mark read/unread, importance, categorize, flag; delete withconfirm=true. Steps that reply, forward or create items aren't run, and anything not understood is reported rather than guessed.move_mailsfiles many messages at once (optionally marking read, adding categories or flagging).check_waitinggoes through your Waiting folder (found from your Waiting Quick Step) and lists which items got a reply from someone else since you filed them, and which are still waiting and for how long;move_answered_tomoves the answered ones back.Two ready-made prompts in the plugin:
/outlook:triage— proposes a bucket for every Inbox message, you approve or change the list, then it files them with your Quick Steps./outlook:brief— Inbox to triage, open Action items, Waiting replies, and today's meetings, on one screen.
If your Quick Steps don't show up as runnable, run
python scripts\export_quick_steps.py once (read-only) and share the
JSON it writes so the format can be supported.
Categories (colours)
create_category(name, color),update_category(recolour / rename),delete_category; colours by name: red, orange, yellow, green, teal, blue, purple, gray, dark blue (navy), gold, brown, … (all 25 of Outlook's).set_categorycolours mails, meetings and tasks: one item or many at once (entry_idsfrom a search),modereplace / add / remove, and a single occurrence of a recurring meeting withoccurrence_start. Category names that don't exist yet are created (incolor), so they always show in colour.create_event/update_eventtakecategoriestoo; a meeting shows in the calendar in its first category's colour.
Rules
create_rule(name, conditions, actions, exceptions)builds an incoming-mail rule like Outlook's Rules wizard. Conditions: from, sent to, words in subject / body / sender address / header, to me / only to me / CC me, has attachment, importance, category. Actions: move or copy to a folder, assign categories (created if missing), flag for follow-up, delete, stop processing, desktop alert, forward / redirect.Preview first. Without
confirm=trueit returns the rule in plain terms and which of the last 30 days' Inbox mail it would have caught, and changes nothing.run_rule(apply to existing mail) anddelete_rulework the same way.list_rules(details=true)explains what each existing rule does.Forward / redirect rules send mail automatically, so they're refused in draft-only mode (the default). With sending allowed they may only target your own email domain, unless
OUTLOOK_MCP_ALLOW_EXTERNAL_FORWARD=1(extra domains:OUTLOOK_MCP_INTERNAL_DOMAINS=corp.com,corp.co.il).Rules are saved to Exchange. Saving rewrites the whole rule list (that's Outlook's API), so avoid editing rules in Outlook or OWA at the same moment. If Outlook makes a rule client-only (it runs only while Outlook is open), the result says so.
Attachments
get_mail lists each attachment with its kind (pdf, word, powerpoint,
excel, image, email, ...) and marks inline images (signature logos);
links to SharePoint / OneDrive / file shares in the body are listed as
linked_files. save_attachments(entry_id) saves the real files —
by default to a per-message folder under
%LOCALAPPDATA%\outlook-mcp\attachments (OUTLOOK_MCP_ATTACHMENTS_DIR
overrides) — skipping inline images, saving attached emails as .msg,
and returns each file's path. Claude then reads them with its own tools
(in Claude Code, Read handles PDFs; Anthropic's document skills or a
script handle Word, PowerPoint and Excel), and a saved path can be
attached to a reply draft directly.
Threads
get_thread(entry_id) returns every message of a conversation in one
call, oldest first — across Inbox, Sent Items and other folders, so your
own replies are included — with each reply's quoted history removed
(English and Hebrew Outlook headers, "Original Message", "On … wrote:").
strip_quoted=false gives full bodies.
Drafting
send_mail,reply_mailandforward_mailall takesave_only=trueto save to Drafts instead of sending. Reply and forward drafts are real Outlook replies: threaded, with the quoted history and its formatting intact. The result includes the draft'sentry_id.send_draft(entry_id)sends a draft once you've reviewed it.Reply text goes inside the message body, above the quoted original, so it uses the message's own font and spacing.
Replies and forwards can add To/CC/BCC recipients, change the subject, and set importance.
signature=trueadds your default Outlook signature (the reply/forward default for replies — not added twice if Outlook already put one in);signature="<name>"picks a saved signature (list_signatureslists them). Signature images are embedded.Hebrew (and Arabic) text is written as right-to-left paragraphs, the way Outlook does it, so drafts are aligned and punctuated correctly; mixed lines take the direction of their first letter. Hebrew text in a new mail or a reply to a plain-text mail is sent as HTML, since plain text can't carry direction.
Recipients are resolved before saving or sending; a send with unresolvable names is refused instead of failing inside Outlook.
Calendar
Other people's calendars:
list_events(mailbox="ann@corp.com")reads a colleague's calendar if they've shared it with you (or you're their delegate).Free/busy for anyone:
get_free_busy(people=[...])shows when people are busy, tentative or out of office, from Exchange free/busy — no calendar permission needed, like Outlook's Scheduling Assistant.Meeting titles where you have access: for colleagues whose calendar is shared with you (or who you're a delegate for),
get_free_busyandfind_meeting_timesalso show their meetings' titles and locations; everyone else stays busy/free only (accesssays which). Private appointments always show as "Private appointment".Calendar history and patterns (לו״ז intelligence):
list_eventsworks on past ranges too (with paging, compact rows and attendees), andcalendar_stats(mailbox, start, end)summarizes someone's calendar over weeks or months — meeting load per week / weekday / hour, typical first and last meeting, recurring meetings with their usual day and time, who they meet most (and 1:1s), organizers, busiest days. It works on your calendar and calendars shared with you, and falls back to free/busy times for others; private appointments are counted, never named.Find a time:
find_meeting_times(attendees=[...], duration_minutes=60)returns slots when you and every required attendee are free, within working hours (day_start/day_end) and working days (working_days=["sun","mon","tue","wed","thu"]for a Sunday–Thursday week). Optional attendees who'd miss a slot are listed with it.All-day events (
all_day=true, dates only).Meetings can be saved without sending invitations (
send_invites=false).update_eventchanges only your calendar unlesssend_update=true; it can add and remove attendees.Deleting a meeting you organize sends a cancellation first (
send_cancellation=falseto skip).Recurring meetings: pass
occurrence_startto change, delete or respond to a single occurrence. Changing a whole series needsapply_to_series=true, so "move tomorrow's standup" can't move all of them by accident.Meeting responses can include a comment.
Safety: drafts first
By default the server cannot send anything. Compose tools always save
to Drafts, send_draft is refused, meeting invites and updates are saved
unsent, cancellations are refused, and meeting responses wait in Drafts.
You review and send from Outlook.
To let it send, set OUTLOOK_MCP_ALLOW_SEND=1 in the server's
environment. OUTLOOK_MCP_DRAFT_ONLY=1 always forces draft-only, even if
sending is allowed elsewhere (useful for IT-managed configs).
In Claude Code you can also gate individual tools. For example, in
.claude/settings.json (tool names below are for a server registered
manually as outlook; installed as the plugin they are
mcp__plugin_outlook_outlook__outlook_... — /mcp shows the real names):
{
"permissions": {
"allow": [
"mcp__outlook__outlook_whoami",
"mcp__outlook__outlook_list_mails",
"mcp__outlook__outlook_search_mails",
"mcp__outlook__outlook_get_mail",
"mcp__outlook__outlook_list_folders",
"mcp__outlook__outlook_list_events",
"mcp__outlook__outlook_get_event",
"mcp__outlook__outlook_list_signatures"
],
"deny": [
"mcp__outlook__outlook_delete_mail",
"mcp__outlook__outlook_toggle_rule"
]
}
}Everything not listed asks for approval each time.
Email bodies are written by other people and end up in the model's context, so treat them as untrusted input — another reason to keep sending behind a review step.
MCP Apps — interactive UI in the chat
Since v0.3.0 the server implements the MCP Apps extension (SEP-1865): read tools ship a self-contained HTML view that supporting hosts (Claude, Claude Desktop, VS Code Copilot, Goose, Postman, …) render in a sandboxed iframe right inside the conversation — instead of a wall of text you get a real inbox, agenda, or contact list. Hosts without MCP Apps support are unaffected and keep getting the usual markdown.

View | Rendered by | What you can do in it |
Mail list |
| open mails in a reading pane, mark read/unread, flag, delete, filter unread, refresh |
Mail reader |
| full body + attachment list, mark, flag, delete |
Calendar agenda |
| day-grouped agenda, expand an event for attendees + body, refresh |
Contacts |
| live search (incl. org directory), copy addresses |
Tasks |
| complete tasks, quick-add new ones, show completed, refresh |

The views are plain inline HTML/CSS/JS (no build step, no external
CDNs — the sandbox CSP blocks those anyway), follow the host's
light/dark theme, and talk back over the standard postMessage
JSON-RPC dialect: buttons in the UI call the same outlook_* tools the
model uses, and in-app actions (delete, complete, …) are reported back
into the model's context so the conversation stays in sync.
Technically: each UI tool carries _meta.ui.resourceUri pointing at a
ui://outlook/*.html resource (mime text/html;profile=mcp-app) and
returns markdown for the model plus structuredContent for the
app. To preview the views without an MCP host:
python scripts/preview_ui.py, then open
.ui-preview/harness.html?view=mail-list (any view name, optional
&theme=dark) in a browser.
Agent skill
The repo also ships an agent skill at skills/outlook/ (standard Agent Skills format — works in Claude Code, Cowork, Copilot, Cursor, and other agents that load skills) — a self-contained operational reference that teaches the agent how to drive the outlook_* tools correctly: folder reference syntax, the EntryID handle pattern, ISO-8601 date conventions, the Recurrence object, which calls have side effects to confirm before, and 19 worked recipes for common workflows (triage, drafting replies, weekly digests, scheduling meetings, recurring events, attachment handling, multi-mailbox setups).
Layout:
skills/outlook/
├── SKILL.md # always-loaded operational core
└── references/ # loaded on demand
├── tools.md # full per-tool parameter / return-shape reference
├── recipes.md # worked multi-step workflows
├── gotchas.md # quirks + failure modes (Programmatic Access prompt, EX:/O= addresses, live rule toggling, sandboxed paths, etc.)
└── setup.md # install instructions an agent can walk a user through when the tools aren't connected yetInstalling the plugin auto-loads this skill alongside the MCP server. For an agent that supports skills but not plugins, copy the skills/outlook/ directory into wherever it loads skills from.
Conventions
Folder references can be:
A well-known name:
inbox,sent,drafts,deleted,outbox,junk,calendar,contacts,tasks,notesA slash path:
Inbox/Projects/AcmeA path qualified by store name:
Mailbox - you@example.com/Inbox/Projects/Acme
Use outlook_list_folders to discover paths.
Dates / times are ISO-8601 strings. Inputs without a timezone are
treated as local time (what Outlook stores); returned timestamps carry
the user's local UTC offset explicitly (2026-06-10T16:33:22+05:00).
Item IDs are Outlook EntryID strings. Read tools return them
on every item; pass them back to detail / edit / delete tools.
Response format — most read tools accept response_format:
markdown(default) — pretty rendered outputjson— full structured data
Errors are raised, so the MCP host marks the response
isError: true. Error messages try to suggest a corrective next step.
Filesystem paths for attachments= and output_dir= must be
absolute and under the user profile (default sandbox). Add other folders
with OUTLOOK_MCP_ALLOWED_PATHS (;-separated), or set
OUTLOOK_MCP_ALLOW_ANY_PATH=1 to disable the sandbox entirely.
Environment variables
Variable | Effect |
| Allow sending. Off by default: everything is saved as a draft; see Safety. |
| Force draft-only even if sending is allowed. |
| Allow forward/redirect rules to addresses outside your domain (needs sending allowed). |
| Extra domains (comma-separated) treated as internal for forward rules. |
| Extra folders for attachments / saved attachments. |
| Disable the path sandbox. |
| Where |
| Signatures folder, if not |
| Log level ( |
Architecture
+-------------------+
stdio <---> | FastMCP server | <-- one per process
+---------+---------+
|
await bridge.call(...)
|
v
+-------------------+
| OutlookBridge | persistent STA thread
| - one Dispatch | single Outlook.Application
| - work queue | handle, reused by every call
+---------+---------+
|
Outlook COM (auto-launches OUTLOOK.EXE if needed)The MCP event loop never blocks on COM, and COM only ever sees the one STA thread it needs. This is faster than per-call dispatch and the Outlook process stays warm across calls.
Development
.venv\Scripts\activate
pip install -e .[dev]
pytestSmoke test the running server with the MCP inspector:
npx @modelcontextprotocol/inspector .venv\Scripts\python.exe -m outlook_mcpThe inspector mangles backslashes on Windows — use forward-slash paths if you hit "ENOENT" errors.
To check everything against your real Outlook (draft-only is forced, and the one test draft and test appointment it creates are deleted after):
.venv\Scripts\python scripts\smoke_test.py --with colleague@yourcompany.comTests mock COM, so they run on any OS (tests/conftest.py stubs
pywin32 off Windows; a handful of bridge tests need real pywin32 and
only run on Windows). CI runs both.
Notes & caveats
The first call after a cold start takes a few seconds — Outlook's COM surface boots up. After that, calls are fast (one Dispatch handle is reused).
Closing Outlook while the server is running is fine: the next tool call detects the dead COM connection, relaunches OUTLOOK.EXE, reconnects, and retries automatically (expect that one call to take 15–30 s).
Outlook auto-launch relies on standard COM behavior. On tightly-locked-down machines (UAC, group policy blocking COM activation), open Outlook manually and try again.
Send / reply / forward / delete may trigger Outlook's "Programmatic Access" security prompts on some corporate machines. If your IT policy blocks programmatic send entirely, write tools will fail — read tools still work. Resolving recipients against the address book can trigger the same prompt.
Some properties (e.g.
SenderEmailAddressfor Exchange addresses) come back asEX:/O=...distinguished names rather than SMTP. Usefrom_addresssubstring matching instead of exact equality — orsearch_mails(scope='from'), which also matches the real SMTP address.Toggling mail rules modifies live rules immediately — there is no staging buffer. Confirm the rule name with
outlook_list_rulesbefore callingoutlook_toggle_rule. Creating, running and deleting rules preview first and needconfirm=true.This server is local-only. Do not expose it over a network.
Troubleshooting
"Outlook COM thread did not become ready" — Outlook didn't auto-launch. Open it manually, sign in, then restart the MCP client so it re-spawns the server.
Inspector shows ENOENT for the python path — known Windows
quirk; use forward slashes (C:/Users/you/...) instead of
backslashes.
Send / reply gets blocked silently — Outlook → File → Options → Trust Center → Programmatic Access. The setting that works while you're using the server is "Never warn me about suspicious activity (not recommended)" — or have IT add the Python interpreter as a trusted publisher.
What's different in this fork
Merged from upstream pull requests that were open at the time:
#19 — event and task times were written one UTC offset early.
#11 — date filters broke on non-US date formats; multi-day events were missed; attachment errors failed whole mail reads; faster failure while Outlook reconnects.
#16 — recipients resolved before saving drafts.
#18 — send from a chosen account; default signature on new mail.
Added here (mostly from upstream issue #13):
Reply and forward drafts (
save_only),send_draft, and draft-only mode (on by default).Other people's calendars, free/busy lookup and a meeting-time finder.
Reply/forward text inserted inside the HTML body instead of before
<html>; plain-text replies no longer flatten an HTML thread.To/CC/BCC, subject and importance on replies and forwards.
Named signatures, default reply signatures, embedded signature images.
All-day events, unsent meetings, meeting updates and cancellations, attendee changes, single-occurrence edits and the series guard, busy status, optional attendees, response comments.
Date filters (which Outlook evaluates in UTC) now convert local times to UTC, so "since this morning" means this morning.
OUTLOOK_MCP_ALLOWED_PATHSfor attachment folders outside the profile.
See CHANGELOG.md for details.
License
MIT — original work © Anas Ahmed Shaikh, fork changes © Ori Harel.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Hosted email MCP for your own Gmail, Outlook.com, Microsoft 365, iCloud or IMAP inbox: read, search, draft, reply in thread, forward and file mail. It moves or flags up to 500 messages in one call, and a send leaves exactly one copy in Sent. A calendar is a separate connection, and connecting one adds diary and scheduling tools.
Hosted MCP server for your Gmail, Outlook and IMAP mail, with mailboxes and scopes set per agent.
Email infrastructure for AI agents — send, receive, search, and reply to email over MCP.
Your agent needs a mailbox of its own — to receive, thread, draft and send, with attachments, without borrowing your personal inbox or your company's SMTP. **What you can ask for** • "Create an inbox for this agent and tell me its address." • "Read the new messages in this thread and draft a reply." • "Send this message with the attachment and wait for the response." • "Search this inbox for everything from that domain." • "Show delivery metrics and the events on this inbox." **How to use it** Point any MCP client at https://mcp.aisa.one/mail/mcp and sign in with OAuth — there is no key to create or paste. 49 tools: create and delete inboxes, list and read messages, raw message bodies, attachments, threads, drafts and draft attachments, send and reply, message search, inbox events, metrics, and list entries — reads and writes. **Why this rather than the source** A real inbox an agent owns, rather than an SMTP credential it borrows from a human. **It is also a door to the rest** The same login reaches 26 sources and 580+ operations. Find the contact elsewhere in the catalogue, then write to them from here — without adding a second server. **What it costs** Finding and inspecting an operation is free. Running one is billed per call at API prices, with no seat and no monthly minimum, and every call takes max_price_usd so an agent cannot overspend by accident. **Where else it reaches** https://mcp.aisa.one/sales/mcp finds the person to write to.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables MCP-aware agents to interact with the classic Outlook desktop client for mail, calendar, contacts, tasks, and Out-of-Office settings via the COM API, without Azure or OAuth.954 PyPI39MIT
- FlicenseNot gradedqualityDmaintenanceProvides LLMs with access to Microsoft Outlook email functionality, allowing them to read, search, compose, and manage emails through a standardized MCP interface on Windows.-
- AlicenseBqualityBmaintenanceEnables AI agents to read, search, send, and organize mail, folders, messages, and threads through a local MCP server. It supports multiple data centers, attachments, and secure credential storage.333MIT
- AlicenseNot gradedqualityCmaintenanceEnables MCP clients to work with a Microsoft Exchange mailbox over EWS, covering mail reading, searching and filing, calendar viewing and editing, free/busy checks, meeting-room discovery and booking, and sending mail with attachments, signatures and delayed delivery. Includes dry-run previews, recoverable deletes, attachment sandboxing, and read-only or no-send modes.MIT